[llvm] r306166 - [ORC] Move ORC IR layer interface from addModuleSet to addModule and fix the
Lang Hames via llvm-commits
llvm-commits at lists.llvm.org
Fri Jun 23 19:30:37 PDT 2017
No worries. :)
- Lang.
On Fri, Jun 23, 2017 at 4:26 PM, Rafael Avila de Espindola <
rafael.espindola at gmail.com> wrote:
> Oh, sorry :-(
>
> Cheers,
> Rafael
>
> Lang Hames <lhames at gmail.com> writes:
>
> > Ugh. Too late. ><
> >
> > On Fri, Jun 23, 2017 at 4:05 PM, Lang Hames <lhames at gmail.com> wrote:
> >
> >> I've got in a fix in the works. Should be in shortly.
> >>
> >> - Lang.
> >>
> >>
> >> On Fri, Jun 23, 2017 at 3:50 PM, Rafael Avila de Espindola <
> >> rafael.espindola at gmail.com> wrote:
> >>
> >>> This is causing test failures on linux. Reverting.
> >>>
> >>> Cheers,
> >>> Rafael
> >>>
> >>> Lang Hames via llvm-commits <llvm-commits at lists.llvm.org> writes:
> >>>
> >>> > Author: lhames
> >>> > Date: Fri Jun 23 16:45:29 2017
> >>> > New Revision: 306166
> >>> >
> >>> > URL: http://llvm.org/viewvc/llvm-project?rev=306166&view=rev
> >>> > Log:
> >>> > [ORC] Move ORC IR layer interface from addModuleSet to addModule and
> >>> fix the
> >>> > module type as std::shared_ptr<Module>.
> >>> >
> >>> >
> >>> > Modified:
> >>> > llvm/trunk/examples/Kaleidoscope/BuildingAJIT/Chapter1/
> >>> KaleidoscopeJIT.h
> >>> > llvm/trunk/examples/Kaleidoscope/BuildingAJIT/Chapter2/
> >>> KaleidoscopeJIT.h
> >>> > llvm/trunk/examples/Kaleidoscope/BuildingAJIT/Chapter3/
> >>> KaleidoscopeJIT.h
> >>> > llvm/trunk/examples/Kaleidoscope/BuildingAJIT/Chapter4/
> >>> KaleidoscopeJIT.h
> >>> > llvm/trunk/examples/Kaleidoscope/BuildingAJIT/Chapter5/
> >>> KaleidoscopeJIT.h
> >>> > llvm/trunk/examples/Kaleidoscope/include/KaleidoscopeJIT.h
> >>> > llvm/trunk/include/llvm-c/OrcBindings.h
> >>> > llvm/trunk/include/llvm/ExecutionEngine/Orc/
> CompileOnDemandLayer.h
> >>> > llvm/trunk/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h
> >>> > llvm/trunk/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h
> >>> > llvm/trunk/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h
> >>> > llvm/trunk/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h
> >>> > llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindings.cpp
> >>> > llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
> >>> > llvm/trunk/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
> >>> > llvm/trunk/tools/lli/OrcLazyJIT.cpp
> >>> > llvm/trunk/tools/lli/OrcLazyJIT.h
> >>> > llvm/trunk/unittests/ExecutionEngine/Orc/
> LazyEmittingLayerTest.cpp
> >>> > llvm/trunk/unittests/ExecutionEngine/Orc/ObjectTransformLay
> >>> erTest.cpp
> >>> > llvm/trunk/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp
> >>> > llvm/trunk/unittests/ExecutionEngine/Orc/OrcTestCommon.h
> >>> >
> >>> > Modified: llvm/trunk/examples/Kaleidoscope/BuildingAJIT/Chapter1/
> >>> KaleidoscopeJIT.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/examples/Kale
> >>> idoscope/BuildingAJIT/Chapter1/KaleidoscopeJIT.h?rev=306166&
> >>> r1=306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/examples/Kaleidoscope/BuildingAJIT/
> Chapter1/KaleidoscopeJIT.h
> >>> (original)
> >>> > +++ llvm/trunk/examples/Kaleidoscope/BuildingAJIT/
> Chapter1/KaleidoscopeJIT.h
> >>> Fri Jun 23 16:45:29 2017
> >>> > @@ -44,7 +44,7 @@ private:
> >>> > IRCompileLayer<decltype(ObjectLayer), SimpleCompiler>
> CompileLayer;
> >>> >
> >>> > public:
> >>> > - using ModuleHandle = decltype(CompileLayer)::ModuleSetHandleT;
> >>> > + using ModuleHandle = decltype(CompileLayer)::ModuleHandleT;
> >>> >
> >>> > KaleidoscopeJIT()
> >>> > : TM(EngineBuilder().selectTarget()),
> >>> DL(TM->createDataLayout()),
> >>> > @@ -72,15 +72,11 @@ public:
> >>> > return JITSymbol(nullptr);
> >>> > });
> >>> >
> >>> > - // Build a singleton module set to hold our module.
> >>> > - std::vector<std::unique_ptr<Module>> Ms;
> >>> > - Ms.push_back(std::move(M));
> >>> > -
> >>> > // Add the set to the JIT with the resolver we created above
> and a
> >>> newly
> >>> > // created SectionMemoryManager.
> >>> > - return CompileLayer.addModuleSet(std::move(Ms),
> >>> > - make_unique<SectionMemoryMana
> >>> ger>(),
> >>> > - std::move(Resolver));
> >>> > + return CompileLayer.addModule(std::move(M),
> >>> > + make_unique<
> SectionMemoryManager>(),
> >>> > + std::move(Resolver));
> >>> > }
> >>> >
> >>> > JITSymbol findSymbol(const std::string Name) {
> >>> > @@ -91,7 +87,7 @@ public:
> >>> > }
> >>> >
> >>> > void removeModule(ModuleHandle H) {
> >>> > - CompileLayer.removeModuleSet(H);
> >>> > + CompileLayer.removeModule(H);
> >>> > }
> >>> > };
> >>> >
> >>> >
> >>> > Modified: llvm/trunk/examples/Kaleidoscope/BuildingAJIT/Chapter2/
> >>> KaleidoscopeJIT.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/examples/Kale
> >>> idoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h?rev=306166&
> >>> r1=306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/examples/Kaleidoscope/BuildingAJIT/
> Chapter2/KaleidoscopeJIT.h
> >>> (original)
> >>> > +++ llvm/trunk/examples/Kaleidoscope/BuildingAJIT/
> Chapter2/KaleidoscopeJIT.h
> >>> Fri Jun 23 16:45:29 2017
> >>> > @@ -48,18 +48,18 @@ private:
> >>> > IRCompileLayer<decltype(ObjectLayer), SimpleCompiler>
> CompileLayer;
> >>> >
> >>> > using OptimizeFunction =
> >>> > - std::function<std::unique_ptr<Module>(std::unique_ptr<
> Module>)>;
> >>> > + std::function<std::shared_ptr<Module>(std::shared_ptr<
> Module>)>;
> >>> >
> >>> > IRTransformLayer<decltype(CompileLayer), OptimizeFunction>
> >>> OptimizeLayer;
> >>> >
> >>> > public:
> >>> > - using ModuleHandle = decltype(OptimizeLayer)::ModuleSetHandleT;
> >>> > + using ModuleHandle = decltype(OptimizeLayer)::ModuleHandleT;
> >>> >
> >>> > KaleidoscopeJIT()
> >>> > : TM(EngineBuilder().selectTarget()),
> >>> DL(TM->createDataLayout()),
> >>> > CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
> >>> > OptimizeLayer(CompileLayer,
> >>> > - [this](std::unique_ptr<Module> M) {
> >>> > + [this](std::shared_ptr<Module> M) {
> >>> > return optimizeModule(std::move(M));
> >>> > }) {
> >>> > llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
> >>> > @@ -85,15 +85,11 @@ public:
> >>> > return JITSymbol(nullptr);
> >>> > });
> >>> >
> >>> > - // Build a singleton module set to hold our module.
> >>> > - std::vector<std::unique_ptr<Module>> Ms;
> >>> > - Ms.push_back(std::move(M));
> >>> > -
> >>> > // Add the set to the JIT with the resolver we created above
> and a
> >>> newly
> >>> > // created SectionMemoryManager.
> >>> > - return OptimizeLayer.addModuleSet(std::move(Ms),
> >>> > - make_unique<SectionMemoryManag
> >>> er>(),
> >>> > - std::move(Resolver));
> >>> > + return OptimizeLayer.addModule(std::move(M),
> >>> > + make_unique<SectionMemoryMana
> >>> ger>(),
> >>> > + std::move(Resolver));
> >>> > }
> >>> >
> >>> > JITSymbol findSymbol(const std::string Name) {
> >>> > @@ -104,11 +100,11 @@ public:
> >>> > }
> >>> >
> >>> > void removeModule(ModuleHandle H) {
> >>> > - OptimizeLayer.removeModuleSet(H);
> >>> > + OptimizeLayer.removeModule(H);
> >>> > }
> >>> >
> >>> > private:
> >>> > - std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module>
> M) {
> >>> > + std::shared_ptr<Module> optimizeModule(std::shared_ptr<Module>
> M) {
> >>> > // Create a function pass manager.
> >>> > auto FPM = llvm::make_unique<legacy::Func
> >>> tionPassManager>(M.get());
> >>> >
> >>> >
> >>> > Modified: llvm/trunk/examples/Kaleidoscope/BuildingAJIT/Chapter3/
> >>> KaleidoscopeJIT.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/examples/Kale
> >>> idoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h?rev=306166&
> >>> r1=306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/examples/Kaleidoscope/BuildingAJIT/
> Chapter3/KaleidoscopeJIT.h
> >>> (original)
> >>> > +++ llvm/trunk/examples/Kaleidoscope/BuildingAJIT/
> Chapter3/KaleidoscopeJIT.h
> >>> Fri Jun 23 16:45:29 2017
> >>> > @@ -51,7 +51,7 @@ private:
> >>> > IRCompileLayer<decltype(ObjectLayer), SimpleCompiler>
> CompileLayer;
> >>> >
> >>> > using OptimizeFunction =
> >>> > - std::function<std::unique_ptr<Module>(std::unique_ptr<
> Module>)>;
> >>> > + std::function<std::shared_ptr<Module>(std::shared_ptr<
> Module>)>;
> >>> >
> >>> > IRTransformLayer<decltype(CompileLayer), OptimizeFunction>
> >>> OptimizeLayer;
> >>> >
> >>> > @@ -59,13 +59,13 @@ private:
> >>> > CompileOnDemandLayer<decltype(OptimizeLayer)> CODLayer;
> >>> >
> >>> > public:
> >>> > - using ModuleHandle = decltype(CODLayer)::ModuleSetHandleT;
> >>> > + using ModuleHandle = decltype(CODLayer)::ModuleHandleT;
> >>> >
> >>> > KaleidoscopeJIT()
> >>> > : TM(EngineBuilder().selectTarget()),
> >>> DL(TM->createDataLayout()),
> >>> > CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
> >>> > OptimizeLayer(CompileLayer,
> >>> > - [this](std::unique_ptr<Module> M) {
> >>> > + [this](std::shared_ptr<Module> M) {
> >>> > return optimizeModule(std::move(M));
> >>> > }),
> >>> > CompileCallbackManager(
> >>> > @@ -98,15 +98,11 @@ public:
> >>> > return JITSymbol(nullptr);
> >>> > });
> >>> >
> >>> > - // Build a singleton module set to hold our module.
> >>> > - std::vector<std::unique_ptr<Module>> Ms;
> >>> > - Ms.push_back(std::move(M));
> >>> > -
> >>> > // Add the set to the JIT with the resolver we created above
> and a
> >>> newly
> >>> > // created SectionMemoryManager.
> >>> > - return CODLayer.addModuleSet(std::move(Ms),
> >>> > - make_unique<
> SectionMemoryManager>(),
> >>> > - std::move(Resolver));
> >>> > + return CODLayer.addModule(std::move(M),
> >>> > + make_unique<SectionMemoryManager>(),
> >>> > + std::move(Resolver));
> >>> > }
> >>> >
> >>> > JITSymbol findSymbol(const std::string Name) {
> >>> > @@ -117,11 +113,11 @@ public:
> >>> > }
> >>> >
> >>> > void removeModule(ModuleHandle H) {
> >>> > - CODLayer.removeModuleSet(H);
> >>> > + CODLayer.removeModule(H);
> >>> > }
> >>> >
> >>> > private:
> >>> > - std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module>
> M) {
> >>> > + std::shared_ptr<Module> optimizeModule(std::shared_ptr<Module>
> M) {
> >>> > // Create a function pass manager.
> >>> > auto FPM = llvm::make_unique<legacy::Func
> >>> tionPassManager>(M.get());
> >>> >
> >>> >
> >>> > Modified: llvm/trunk/examples/Kaleidoscope/BuildingAJIT/Chapter4/
> >>> KaleidoscopeJIT.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/examples/Kale
> >>> idoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h?rev=306166&
> >>> r1=306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/examples/Kaleidoscope/BuildingAJIT/
> Chapter4/KaleidoscopeJIT.h
> >>> (original)
> >>> > +++ llvm/trunk/examples/Kaleidoscope/BuildingAJIT/
> Chapter4/KaleidoscopeJIT.h
> >>> Fri Jun 23 16:45:29 2017
> >>> > @@ -77,7 +77,7 @@ private:
> >>> > IRCompileLayer<decltype(ObjectLayer), SimpleCompiler>
> CompileLayer;
> >>> >
> >>> > using OptimizeFunction =
> >>> > - std::function<std::unique_ptr<Module>(std::unique_ptr<
> Module>)>;
> >>> > + std::function<std::shared_ptr<Module>(std::shared_ptr<
> Module>)>;
> >>> >
> >>> > IRTransformLayer<decltype(CompileLayer), OptimizeFunction>
> >>> OptimizeLayer;
> >>> >
> >>> > @@ -85,14 +85,14 @@ private:
> >>> > std::unique_ptr<IndirectStubsManager> IndirectStubsMgr;
> >>> >
> >>> > public:
> >>> > - using ModuleHandle = decltype(OptimizeLayer)::ModuleSetHandleT;
> >>> > + using ModuleHandle = decltype(OptimizeLayer)::ModuleHandleT;
> >>> >
> >>> > KaleidoscopeJIT()
> >>> > : TM(EngineBuilder().selectTarget()),
> >>> > DL(TM->createDataLayout()),
> >>> > CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
> >>> > OptimizeLayer(CompileLayer,
> >>> > - [this](std::unique_ptr<Module> M) {
> >>> > + [this](std::shared_ptr<Module> M) {
> >>> > return optimizeModule(std::move(M));
> >>> > }),
> >>> > CompileCallbackMgr(
> >>> > @@ -125,15 +125,11 @@ public:
> >>> > return JITSymbol(nullptr);
> >>> > });
> >>> >
> >>> > - // Build a singleton module set to hold our module.
> >>> > - std::vector<std::unique_ptr<Module>> Ms;
> >>> > - Ms.push_back(std::move(M));
> >>> > -
> >>> > // Add the set to the JIT with the resolver we created above
> and a
> >>> newly
> >>> > // created SectionMemoryManager.
> >>> > - return OptimizeLayer.addModuleSet(std::move(Ms),
> >>> > - make_unique<SectionMemoryManag
> >>> er>(),
> >>> > - std::move(Resolver));
> >>> > + return OptimizeLayer.addModule(std::move(M),
> >>> > + make_unique<SectionMemoryMana
> >>> ger>(),
> >>> > + std::move(Resolver));
> >>> > }
> >>> >
> >>> > Error addFunctionAST(std::unique_ptr<FunctionAST> FnAST) {
> >>> > @@ -199,7 +195,7 @@ public:
> >>> > }
> >>> >
> >>> > void removeModule(ModuleHandle H) {
> >>> > - OptimizeLayer.removeModuleSet(H);
> >>> > + OptimizeLayer.removeModule(H);
> >>> > }
> >>> >
> >>> > private:
> >>> > @@ -210,7 +206,7 @@ private:
> >>> > return MangledNameStream.str();
> >>> > }
> >>> >
> >>> > - std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module>
> M) {
> >>> > + std::shared_ptr<Module> optimizeModule(std::shared_ptr<Module>
> M) {
> >>> > // Create a function pass manager.
> >>> > auto FPM = llvm::make_unique<legacy::Func
> >>> tionPassManager>(M.get());
> >>> >
> >>> >
> >>> > Modified: llvm/trunk/examples/Kaleidoscope/BuildingAJIT/Chapter5/
> >>> KaleidoscopeJIT.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/examples/Kale
> >>> idoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h?rev=306166&
> >>> r1=306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/examples/Kaleidoscope/BuildingAJIT/
> Chapter5/KaleidoscopeJIT.h
> >>> (original)
> >>> > +++ llvm/trunk/examples/Kaleidoscope/BuildingAJIT/
> Chapter5/KaleidoscopeJIT.h
> >>> Fri Jun 23 16:45:29 2017
> >>> > @@ -82,7 +82,7 @@ private:
> >>> > IRCompileLayer<decltype(ObjectLayer), SimpleCompiler>
> CompileLayer;
> >>> >
> >>> > using OptimizeFunction =
> >>> > - std::function<std::unique_ptr<Module>(std::unique_ptr<
> Module>)>;
> >>> > + std::function<std::shared_ptr<Module>(std::shared_ptr<
> Module>)>;
> >>> >
> >>> > IRTransformLayer<decltype(CompileLayer), OptimizeFunction>
> >>> OptimizeLayer;
> >>> >
> >>> > @@ -91,7 +91,7 @@ private:
> >>> > MyRemote &Remote;
> >>> >
> >>> > public:
> >>> > - using ModuleHandle = decltype(OptimizeLayer)::ModuleSetHandleT;
> >>> > + using ModuleHandle = decltype(OptimizeLayer)::ModuleHandleT;
> >>> >
> >>> > KaleidoscopeJIT(MyRemote &Remote)
> >>> > : TM(EngineBuilder().selectTarget(Triple(Remote.
> getTargetTriple()),
> >>> "",
> >>> > @@ -99,7 +99,7 @@ public:
> >>> > DL(TM->createDataLayout()),
> >>> > CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
> >>> > OptimizeLayer(CompileLayer,
> >>> > - [this](std::unique_ptr<Module> M) {
> >>> > + [this](std::shared_ptr<Module> M) {
> >>> > return optimizeModule(std::move(M));
> >>> > }),
> >>> > Remote(Remote) {
> >>> > @@ -153,15 +153,11 @@ public:
> >>> > exit(1);
> >>> > }
> >>> >
> >>> > - // Build a singleton module set to hold our module.
> >>> > - std::vector<std::unique_ptr<Module>> Ms;
> >>> > - Ms.push_back(std::move(M));
> >>> > -
> >>> > // Add the set to the JIT with the resolver we created above
> and a
> >>> newly
> >>> > // created SectionMemoryManager.
> >>> > - return OptimizeLayer.addModuleSet(std::move(Ms),
> >>> > - std::move(MemMgr),
> >>> > - std::move(Resolver));
> >>> > + return OptimizeLayer.addModule(std::move(M),
> >>> > + std::move(MemMgr),
> >>> > + std::move(Resolver));
> >>> > }
> >>> >
> >>> > Error addFunctionAST(std::unique_ptr<FunctionAST> FnAST) {
> >>> > @@ -231,7 +227,7 @@ public:
> >>> > }
> >>> >
> >>> > void removeModule(ModuleHandle H) {
> >>> > - OptimizeLayer.removeModuleSet(H);
> >>> > + OptimizeLayer.removeModule(H);
> >>> > }
> >>> >
> >>> > private:
> >>> > @@ -242,7 +238,7 @@ private:
> >>> > return MangledNameStream.str();
> >>> > }
> >>> >
> >>> > - std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module>
> M) {
> >>> > + std::shared_ptr<Module> optimizeModule(std::shared_ptr<Module>
> M) {
> >>> > // Create a function pass manager.
> >>> > auto FPM = llvm::make_unique<legacy::Func
> >>> tionPassManager>(M.get());
> >>> >
> >>> >
> >>> > Modified: llvm/trunk/examples/Kaleidoscope/include/KaleidoscopeJIT.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/examples/Kale
> >>> idoscope/include/KaleidoscopeJIT.h?rev=306166&r1=306165&r2=
> >>> 306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/examples/Kaleidoscope/include/KaleidoscopeJIT.h
> >>> (original)
> >>> > +++ llvm/trunk/examples/Kaleidoscope/include/KaleidoscopeJIT.h Fri
> Jun
> >>> 23 16:45:29 2017
> >>> > @@ -41,7 +41,7 @@ class KaleidoscopeJIT {
> >>> > public:
> >>> > using ObjLayerT = RTDyldObjectLinkingLayer;
> >>> > using CompileLayerT = IRCompileLayer<ObjLayerT, SimpleCompiler>;
> >>> > - using ModuleHandleT = CompileLayerT::ModuleSetHandleT;
> >>> > + using ModuleHandleT = CompileLayerT::ModuleHandleT;
> >>> >
> >>> > KaleidoscopeJIT()
> >>> > : TM(EngineBuilder().selectTarget()),
> >>> DL(TM->createDataLayout()),
> >>> > @@ -62,9 +62,9 @@ public:
> >>> > return JITSymbol(nullptr);
> >>> > },
> >>> > [](const std::string &S) { return nullptr; });
> >>> > - auto H = CompileLayer.addModuleSet(singletonSet(std::move(M)),
> >>> > - make_unique<SectionMemoryMana
> >>> ger>(),
> >>> > - std::move(Resolver));
> >>> > + auto H = CompileLayer.addModule(std::move(M),
> >>> > + make_unique<SectionMemoryManag
> >>> er>(),
> >>> > + std::move(Resolver));
> >>> >
> >>> > ModuleHandles.push_back(H);
> >>> > return H;
> >>> > @@ -72,7 +72,7 @@ public:
> >>> >
> >>> > void removeModule(ModuleHandleT H) {
> >>> > ModuleHandles.erase(find(ModuleHandles, H));
> >>> > - CompileLayer.removeModuleSet(H);
> >>> > + CompileLayer.removeModule(H);
> >>> > }
> >>> >
> >>> > JITSymbol findSymbol(const std::string Name) {
> >>> > @@ -89,12 +89,6 @@ private:
> >>> > return MangledName;
> >>> > }
> >>> >
> >>> > - template <typename T> static std::vector<T> singletonSet(T t) {
> >>> > - std::vector<T> Vec;
> >>> > - Vec.push_back(std::move(t));
> >>> > - return Vec;
> >>> > - }
> >>> > -
> >>> > JITSymbol findMangledSymbol(const std::string &Name) {
> >>> > #ifdef LLVM_ON_WIN32
> >>> > // The symbol lookup of ObjectLinkingLayer uses the
> >>> SymbolRef::SF_Exported
> >>> >
> >>> > Modified: llvm/trunk/include/llvm-c/OrcBindings.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm-
> >>> c/OrcBindings.h?rev=306166&r1=306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/include/llvm-c/OrcBindings.h (original)
> >>> > +++ llvm/trunk/include/llvm-c/OrcBindings.h Fri Jun 23 16:45:29 2017
> >>> > @@ -29,6 +29,8 @@
> >>> > extern "C" {
> >>> > #endif
> >>> >
> >>> > +typedef struct LLVMOpaqueSharedModule *LLVMSharedModuleRef;
> >>> > +typedef struct LLVMOpaqueSharedObjectBuffer
> *LLVMSharedObjectBufferRef;
> >>> > typedef struct LLVMOrcOpaqueJITStack *LLVMOrcJITStackRef;
> >>> > typedef uint32_t LLVMOrcModuleHandle;
> >>> > typedef uint64_t LLVMOrcTargetAddress;
> >>> > @@ -39,6 +41,45 @@ typedef uint64_t (*LLVMOrcLazyCompileCal
> >>> > typedef enum { LLVMOrcErrSuccess = 0, LLVMOrcErrGeneric }
> >>> LLVMOrcErrorCode;
> >>> >
> >>> > /**
> >>> > + * Turn an LLVMModuleRef into an LLVMSharedModuleRef.
> >>> > + *
> >>> > + * The JIT uses shared ownership for LLVM modules, since it is
> >>> generally
> >>> > + * difficult to know when the JIT will be finished with a module
> (and
> >>> the JIT
> >>> > + * has no way of knowing when a user may be finished with one).
> >>> > + *
> >>> > + * Calling this method with an LLVMModuleRef creates a
> shared-pointer
> >>> to the
> >>> > + * module, and returns a reference to this shared pointer.
> >>> > + *
> >>> > + * The shared module should be disposed when finished with by
> calling
> >>> > + * LLVMOrcDisposeSharedModule (not LLVMDisposeModule). The Module
> will
> >>> be
> >>> > + * deleted when the last shared pointer owner relinquishes it.
> >>> > + */
> >>> > +
> >>> > +LLVMSharedModuleRef LLVMOrcMakeSharedModule(LLVMModuleRef Mod);
> >>> > +
> >>> > +/**
> >>> > + * Dispose of a shared module.
> >>> > + *
> >>> > + * The module should not be accessed after this call. The module
> will
> >>> be
> >>> > + * deleted once all clients (including the JIT itself) have released
> >>> their
> >>> > + * shared pointers.
> >>> > + */
> >>> > +
> >>> > +void LLVMOrcDisposeSharedModuleRef(LLVMSharedModuleRef SharedMod);
> >>> > +
> >>> > +/**
> >>> > + * Get an LLVMSharedObjectBufferRef from an LLVMMemoryBufferRef.
> >>> > + */
> >>> > +LLVMSharedObjectBufferRef
> >>> > +LLVMOrcMakeSharedObjectBuffer(LLVMMemoryBufferRef ObjBuffer);
> >>> > +
> >>> > +/**
> >>> > + * Dispose of a shared object buffer.
> >>> > + */
> >>> > +void
> >>> > +LLVMOrcDisposeSharedObjectBufferRef(LLVMSharedObjectBufferRef
> >>> SharedObjBuffer);
> >>> > +
> >>> > +/**
> >>> > * Create an ORC JIT stack.
> >>> > *
> >>> > * The client owns the resulting stack, and must call
> >>> OrcDisposeInstance(...)
> >>> > @@ -95,7 +136,8 @@ LLVMOrcErrorCode LLVMOrcSetIndirectStubP
> >>> > * Add module to be eagerly compiled.
> >>> > */
> >>> > LLVMOrcModuleHandle
> >>> > -LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack,
> >>> LLVMModuleRef Mod,
> >>> > +LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack,
> >>> > + LLVMSharedModuleRef Mod,
> >>> > LLVMOrcSymbolResolverFn SymbolResolver,
> >>> > void *SymbolResolverCtx);
> >>> >
> >>> > @@ -103,7 +145,8 @@ LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITSt
> >>> > * Add module to be lazily compiled one function at a time.
> >>> > */
> >>> > LLVMOrcModuleHandle
> >>> > -LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack,
> LLVMModuleRef
> >>> Mod,
> >>> > +LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack,
> >>> > + LLVMSharedModuleRef Mod,
> >>> > LLVMOrcSymbolResolverFn SymbolResolver,
> >>> > void *SymbolResolverCtx);
> >>> >
> >>> > @@ -111,7 +154,7 @@ LLVMOrcAddLazilyCompiledIR(LLVMOrcJITSta
> >>> > * Add an object file.
> >>> > */
> >>> > LLVMOrcModuleHandle LLVMOrcAddObjectFile(LLVMOrcJITStackRef
> JITStack,
> >>> > - LLVMObjectFileRef Obj,
> >>> > + LLVMSharedObjectBufferRef
> Obj,
> >>> > LLVMOrcSymbolResolverFn
> >>> SymbolResolver,
> >>> > void *SymbolResolverCtx);
> >>> >
> >>> >
> >>> > Modified: llvm/trunk/include/llvm/ExecutionEngine/Orc/
> CompileOnDemandL
> >>> ayer.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/
> >>> ExecutionEngine/Orc/CompileOnDemandLayer.h?rev=306166&r1=
> >>> 306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/include/llvm/ExecutionEngine/Orc/
> CompileOnDemandLayer.h
> >>> (original)
> >>> > +++ llvm/trunk/include/llvm/ExecutionEngine/Orc/
> CompileOnDemandLayer.h
> >>> Fri Jun 23 16:45:29 2017
> >>> > @@ -84,7 +84,7 @@ private:
> >>> > return LambdaMaterializer<MaterializerFtor>(std::move(M));
> >>> > }
> >>> >
> >>> > - using BaseLayerModuleSetHandleT = typename
> >>> BaseLayerT::ModuleSetHandleT;
> >>> > + using BaseLayerModuleHandleT = typename BaseLayerT::ModuleHandleT;
> >>> >
> >>> > // Provide type-erasure for the Modules and MemoryManagers.
> >>> > template <typename ResourceT>
> >>> > @@ -139,9 +139,11 @@ private:
> >>> > struct LogicalDylib {
> >>> > using SymbolResolverFtor = std::function<JITSymbol(const
> >>> std::string&)>;
> >>> >
> >>> > - using ModuleAdderFtor = std::function<typename
> >>> BaseLayerT::ModuleSetHandleT(
> >>> > - BaseLayerT &, std::unique_ptr<Module>,
> >>> > - std::unique_ptr<JITSymbolResolver>)>;
> >>> > + using ModuleAdderFtor =
> >>> > + std::function<typename BaseLayerT::ModuleHandleT(
> >>> > + BaseLayerT&,
> >>> > + std::unique_ptr<Module>,
> >>> > + std::unique_ptr<JITSymbolResolver>)>;
> >>> >
> >>> > struct SourceModuleEntry {
> >>> > std::unique_ptr<ResourceOwner<Module>> SourceMod;
> >>> > @@ -179,7 +181,7 @@ private:
> >>> >
> >>> > void removeModulesFromBaseLayer(BaseLayerT &BaseLayer) {
> >>> > for (auto &BLH : BaseLayerHandles)
> >>> > - BaseLayer.removeModuleSet(BLH);
> >>> > + BaseLayer.removeModule(BLH);
> >>> > }
> >>> >
> >>> > std::unique_ptr<JITSymbolResolver> ExternalSymbolResolver;
> >>> > @@ -188,14 +190,14 @@ private:
> >>> > StaticGlobalRenamer StaticRenamer;
> >>> > ModuleAdderFtor ModuleAdder;
> >>> > SourceModulesList SourceModules;
> >>> > - std::vector<BaseLayerModuleSetHandleT> BaseLayerHandles;
> >>> > + std::vector<BaseLayerModuleHandleT> BaseLayerHandles;
> >>> > };
> >>> >
> >>> > using LogicalDylibList = std::list<LogicalDylib>;
> >>> >
> >>> > public:
> >>> > - /// @brief Handle to a set of loaded modules.
> >>> > - using ModuleSetHandleT = typename LogicalDylibList::iterator;
> >>> > + /// @brief Handle to loaded module.
> >>> > + using ModuleHandleT = typename LogicalDylibList::iterator;
> >>> >
> >>> > /// @brief Module partitioning functor.
> >>> > using PartitioningFtor = std::function<std::set<Functio
> >>> n*>(Function&)>;
> >>> > @@ -216,15 +218,15 @@ public:
> >>> >
> >>> > ~CompileOnDemandLayer() {
> >>> > while (!LogicalDylibs.empty())
> >>> > - removeModuleSet(LogicalDylibs.begin());
> >>> > + removeModule(LogicalDylibs.begin());
> >>> > }
> >>> > -
> >>> > +
> >>> > /// @brief Add a module to the compile-on-demand layer.
> >>> > - template <typename ModuleSetT, typename MemoryManagerPtrT,
> >>> > - typename SymbolResolverPtrT>
> >>> > - ModuleSetHandleT addModuleSet(ModuleSetT Ms,
> >>> > - MemoryManagerPtrT MemMgr,
> >>> > - SymbolResolverPtrT Resolver) {
> >>> > + template <typename MemoryManagerPtrT, typename SymbolResolverPtrT>
> >>> > + ModuleHandleT addModule(std::shared_ptr<Module> M,
> >>> > + MemoryManagerPtrT MemMgr,
> >>> > + SymbolResolverPtrT Resolver) {
> >>> > +
> >>> > LogicalDylibs.push_back(LogicalDylib());
> >>> > auto &LD = LogicalDylibs.back();
> >>> > LD.ExternalSymbolResolver = std::move(Resolver);
> >>> > @@ -236,23 +238,25 @@ public:
> >>> > LD.ModuleAdder =
> >>> > [&MemMgrRef](BaseLayerT &B, std::unique_ptr<Module> M,
> >>> > std::unique_ptr<JITSymbolResolver> R) {
> >>> > - std::vector<std::unique_ptr<Module>> Ms;
> >>> > - Ms.push_back(std::move(M));
> >>> > - return B.addModuleSet(std::move(Ms), &MemMgrRef,
> std::move(R));
> >>> > + return B.addModule(std::move(M), &MemMgrRef, std::move(R));
> >>> > };
> >>> >
> >>> > // Process each of the modules in this module set.
> >>> > - for (auto &M : Ms)
> >>> > - addLogicalModule(LogicalDylibs.back(), std::move(M));
> >>> > + addLogicalModule(LogicalDylibs.back(), std::move(M));
> >>> >
> >>> > return std::prev(LogicalDylibs.end());
> >>> > }
> >>> >
> >>> > + /// @brief Add extra modules to an existing logical module.
> >>> > + void addExtraModule(ModuleHandleT H, std::shared_ptr<Module> M) {
> >>> > + addLogicalModule(*H, std::move(M));
> >>> > + }
> >>> > +
> >>> > /// @brief Remove the module represented by the given handle.
> >>> > ///
> >>> > /// This will remove all modules in the layers below that were
> >>> derived from
> >>> > /// the module represented by H.
> >>> > - void removeModuleSet(ModuleSetHandleT H) {
> >>> > + void removeModule(ModuleHandleT H) {
> >>> > H->removeModulesFromBaseLayer(BaseLayer);
> >>> > LogicalDylibs.erase(H);
> >>> > }
> >>> > @@ -274,7 +278,7 @@ public:
> >>> >
> >>> > /// @brief Get the address of a symbol provided by this layer, or
> >>> some layer
> >>> > /// below this one.
> >>> > - JITSymbol findSymbolIn(ModuleSetHandleT H, const std::string
> &Name,
> >>> > + JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name,
> >>> > bool ExportedSymbolsOnly) {
> >>> > return H->findSymbol(BaseLayer, Name, ExportedSymbolsOnly);
> >>> > }
> >>> > @@ -498,7 +502,7 @@ private:
> >>> > }
> >>> >
> >>> > template <typename PartitionT>
> >>> > - BaseLayerModuleSetHandleT
> >>> > + BaseLayerModuleHandleT
> >>> > emitPartition(LogicalDylib &LD,
> >>> > typename LogicalDylib::SourceModuleHandle LMId,
> >>> > const PartitionT &Part) {
> >>> >
> >>> > Modified: llvm/trunk/include/llvm/ExecutionEngine/Orc/
> ExecutionUtils.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/
> >>> ExecutionEngine/Orc/ExecutionUtils.h?rev=306166&r1=306165&
> >>> r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h
> >>> (original)
> >>> > +++ llvm/trunk/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h Fri
> >>> Jun 23 16:45:29 2017
> >>> > @@ -94,7 +94,7 @@ public:
> >>> > /// @brief Construct a CtorDtorRunner for the given range using
> the
> >>> given
> >>> > /// name mangling function.
> >>> > CtorDtorRunner(std::vector<std::string> CtorDtorNames,
> >>> > - typename JITLayerT::ModuleSetHandleT H)
> >>> > + typename JITLayerT::ModuleHandleT H)
> >>> > : CtorDtorNames(std::move(CtorDtorNames)), H(H) {}
> >>> >
> >>> > /// @brief Run the recorded constructors/destructors through the
> >>> given JIT
> >>> > @@ -116,7 +116,7 @@ public:
> >>> >
> >>> > private:
> >>> > std::vector<std::string> CtorDtorNames;
> >>> > - typename JITLayerT::ModuleSetHandleT H;
> >>> > + typename JITLayerT::ModuleHandleT H;
> >>> > };
> >>> >
> >>> > /// @brief Support class for static dtor execution. For hosted
> >>> (in-process) JITs
> >>> >
> >>> > Modified: llvm/trunk/include/llvm/ExecutionEngine/Orc/
> IRCompileLayer.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/
> >>> ExecutionEngine/Orc/IRCompileLayer.h?rev=306166&r1=306165&
> >>> r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h
> >>> (original)
> >>> > +++ llvm/trunk/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h Fri
> >>> Jun 23 16:45:29 2017
> >>> > @@ -28,15 +28,15 @@ namespace orc {
> >>> >
> >>> > /// @brief Eager IR compiling layer.
> >>> > ///
> >>> > -/// This layer accepts sets of LLVM IR Modules (via
> addModuleSet). It
> >>> > -/// immediately compiles each IR module to an object file (each IR
> >>> Module is
> >>> > -/// compiled separately). The resulting set of object files is then
> >>> added to
> >>> > -/// the layer below, which must implement the object layer concept.
> >>> > +/// This layer immediately compiles each IR module added via
> >>> addModule to an
> >>> > +/// object file and adds this module file to the layer below, which
> >>> must
> >>> > +/// implement the object layer concept.
> >>> > template <typename BaseLayerT, typename CompileFtor>
> >>> > class IRCompileLayer {
> >>> > public:
> >>> > - /// @brief Handle to a set of compiled modules.
> >>> > - using ModuleSetHandleT = typename BaseLayerT::ObjHandleT;
> >>> > +
> >>> > + /// @brief Handle to a compiled module.
> >>> > + using ModuleHandleT = typename BaseLayerT::ObjHandleT;
> >>> >
> >>> > /// @brief Construct an IRCompileLayer with the given BaseLayer,
> >>> which must
> >>> > /// implement the ObjectLayer concept.
> >>> > @@ -46,25 +46,22 @@ public:
> >>> > /// @brief Get a reference to the compiler functor.
> >>> > CompileFtor& getCompiler() { return Compile; }
> >>> >
> >>> > - /// @brief Compile each module in the given module set, then add
> the
> >>> resulting
> >>> > - /// set of objects to the base layer along with the memory
> >>> manager and
> >>> > - /// symbol resolver.
> >>> > + /// @brief Compile the module, and add the resulting object to the
> >>> base layer
> >>> > + /// along with the given memory manager and symbol
> resolver.
> >>> > ///
> >>> > - /// @return A handle for the added modules.
> >>> > - template <typename ModuleSetT, typename MemoryManagerPtrT,
> >>> > - typename SymbolResolverPtrT>
> >>> > - ModuleSetHandleT addModuleSet(ModuleSetT Ms,
> >>> > - MemoryManagerPtrT MemMgr,
> >>> > - SymbolResolverPtrT Resolver) {
> >>> > - assert(Ms.size() == 1);
> >>> > - using CompileResult = decltype(Compile(*Ms.front()));
> >>> > - auto Obj = std::make_shared<CompileResult>(Compile(*Ms.
> front()));
> >>> > + /// @return A handle for the added module.
> >>> > + template <typename MemoryManagerPtrT, typename SymbolResolverPtrT>
> >>> > + ModuleHandleT addModule(std::shared_ptr<Module> M,
> >>> > + MemoryManagerPtrT MemMgr,
> >>> > + SymbolResolverPtrT Resolver) {
> >>> > + using CompileResult = decltype(Compile(*M));
> >>> > + auto Obj = std::make_shared<CompileResult>(Compile(*M));
> >>> > return BaseLayer.addObject(std::move(Obj), std::move(MemMgr),
> >>> > std::move(Resolver));
> >>> > }
> >>> >
> >>> > - /// @brief Remove the module set associated with the handle H.
> >>> > - void removeModuleSet(ModuleSetHandleT H) {
> >>> BaseLayer.removeObject(H); }
> >>> > + /// @brief Remove the module associated with the handle H.
> >>> > + void removeModule(ModuleHandleT H) { BaseLayer.removeObject(H); }
> >>> >
> >>> > /// @brief Search for the given named symbol.
> >>> > /// @param Name The name of the symbol to search for.
> >>> > @@ -74,23 +71,23 @@ public:
> >>> > return BaseLayer.findSymbol(Name, ExportedSymbolsOnly);
> >>> > }
> >>> >
> >>> > - /// @brief Get the address of the given symbol in the context of
> the
> >>> set of
> >>> > - /// compiled modules represented by the handle H. This
> call is
> >>> > - /// forwarded to the base layer's implementation.
> >>> > - /// @param H The handle for the module set to search in.
> >>> > + /// @brief Get the address of the given symbol in compiled module
> >>> represented
> >>> > + /// by the handle H. This call is forwarded to the base
> >>> layer's
> >>> > + /// implementation.
> >>> > + /// @param H The handle for the module to search in.
> >>> > /// @param Name The name of the symbol to search for.
> >>> > /// @param ExportedSymbolsOnly If true, search only for exported
> >>> symbols.
> >>> > /// @return A handle for the given named symbol, if it is found in
> >>> the
> >>> > - /// given module set.
> >>> > - JITSymbol findSymbolIn(ModuleSetHandleT H, const std::string
> &Name,
> >>> > + /// given module.
> >>> > + JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name,
> >>> > bool ExportedSymbolsOnly) {
> >>> > return BaseLayer.findSymbolIn(H, Name, ExportedSymbolsOnly);
> >>> > }
> >>> >
> >>> > - /// @brief Immediately emit and finalize the moduleOB set
> >>> represented by the
> >>> > - /// given handle.
> >>> > - /// @param H Handle for module set to emit/finalize.
> >>> > - void emitAndFinalize(ModuleSetHandleT H) {
> >>> > + /// @brief Immediately emit and finalize the module represented by
> >>> the given
> >>> > + /// handle.
> >>> > + /// @param H Handle for module to emit/finalize.
> >>> > + void emitAndFinalize(ModuleHandleT H) {
> >>> > BaseLayer.emitAndFinalize(H);
> >>> > }
> >>> >
> >>> >
> >>> > Modified: llvm/trunk/include/llvm/ExecutionEngine/Orc/
> IRTransformLayer
> >>> .h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/
> >>> ExecutionEngine/Orc/IRTransformLayer.h?rev=306166&r1=306165&
> >>> r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h
> >>> (original)
> >>> > +++ llvm/trunk/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h
> Fri
> >>> Jun 23 16:45:29 2017
> >>> > @@ -22,39 +22,34 @@ namespace orc {
> >>> >
> >>> > /// @brief IR mutating layer.
> >>> > ///
> >>> > -/// This layer accepts sets of LLVM IR Modules (via
> addModuleSet). It
> >>> > -/// immediately applies the user supplied functor to each module,
> then
> >>> adds
> >>> > -/// the set of transformed modules to the layer below.
> >>> > +/// 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 IRTransformLayer {
> >>> > public:
> >>> > +
> >>> > /// @brief Handle to a set of added modules.
> >>> > - using ModuleSetHandleT = typename BaseLayerT::ModuleSetHandleT;
> >>> > + using ModuleHandleT = typename BaseLayerT::ModuleHandleT;
> >>> >
> >>> > /// @brief Construct an IRTransformLayer with the given BaseLayer
> >>> > IRTransformLayer(BaseLayerT &BaseLayer,
> >>> > TransformFtor Transform = TransformFtor())
> >>> > : BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
> >>> >
> >>> > - /// @brief Apply the transform functor to each module in the
> module
> >>> set, then
> >>> > - /// add the resulting set of modules to the base layer,
> along
> >>> with the
> >>> > - /// memory manager and symbol resolver.
> >>> > + /// @brief 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.
> >>> > - template <typename ModuleSetT, typename MemoryManagerPtrT,
> >>> > - typename SymbolResolverPtrT>
> >>> > - ModuleSetHandleT addModuleSet(ModuleSetT Ms,
> >>> > - MemoryManagerPtrT MemMgr,
> >>> > - SymbolResolverPtrT Resolver) {
> >>> > - for (auto I = Ms.begin(), E = Ms.end(); I != E; ++I)
> >>> > - *I = Transform(std::move(*I));
> >>> > -
> >>> > - return BaseLayer.addModuleSet(std::move(Ms), std::move(MemMgr),
> >>> > - std::move(Resolver));
> >>> > + template <typename MemoryManagerPtrT, typename SymbolResolverPtrT>
> >>> > + ModuleHandleT addModule(std::shared_ptr<Module> M,
> >>> > + MemoryManagerPtrT MemMgr,
> >>> > + SymbolResolverPtrT Resolver) {
> >>> > + return BaseLayer.addModule(Transform(std::move(M)),
> >>> std::move(MemMgr),
> >>> > + std::move(Resolver));
> >>> > }
> >>> >
> >>> > - /// @brief Remove the module set associated with the handle H.
> >>> > - void removeModuleSet(ModuleSetHandleT H) {
> >>> BaseLayer.removeModuleSet(H); }
> >>> > + /// @brief Remove the module associated with the handle H.
> >>> > + void removeModule(ModuleHandleT H) { BaseLayer.removeModule(H); }
> >>> >
> >>> > /// @brief Search for the given named symbol.
> >>> > /// @param Name The name of the symbol to search for.
> >>> > @@ -64,23 +59,23 @@ public:
> >>> > return BaseLayer.findSymbol(Name, ExportedSymbolsOnly);
> >>> > }
> >>> >
> >>> > - /// @brief Get the address of the given symbol in the context of
> the
> >>> set of
> >>> > - /// modules represented by the handle H. This call is
> >>> forwarded to the
> >>> > - /// base layer's implementation.
> >>> > - /// @param H The handle for the module set to search in.
> >>> > + /// @brief Get the address of the given symbol in the context of
> the
> >>> module
> >>> > + /// represented by the handle H. This call is forwarded to
> >>> the base
> >>> > + /// layer's implementation.
> >>> > + /// @param H The handle for the module to search in.
> >>> > /// @param Name The name of the symbol to search for.
> >>> > /// @param ExportedSymbolsOnly If true, search only for exported
> >>> symbols.
> >>> > /// @return A handle for the given named symbol, if it is found in
> >>> the
> >>> > - /// given module set.
> >>> > - JITSymbol findSymbolIn(ModuleSetHandleT H, const std::string
> &Name,
> >>> > + /// given module.
> >>> > + JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name,
> >>> > bool ExportedSymbolsOnly) {
> >>> > return BaseLayer.findSymbolIn(H, Name, ExportedSymbolsOnly);
> >>> > }
> >>> >
> >>> > - /// @brief Immediately emit and finalize the module set
> represented
> >>> by the
> >>> > - /// given handle.
> >>> > - /// @param H Handle for module set to emit/finalize.
> >>> > - void emitAndFinalize(ModuleSetHandleT H) {
> >>> > + /// @brief Immediately emit and finalize the module represented by
> >>> the given
> >>> > + /// handle.
> >>> > + /// @param H Handle for module to emit/finalize.
> >>> > + void emitAndFinalize(ModuleHandleT H) {
> >>> > BaseLayer.emitAndFinalize(H);
> >>> > }
> >>> >
> >>> >
> >>> > Modified: llvm/trunk/include/llvm/ExecutionEngine/Orc/
> LazyEmittingLaye
> >>> r.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/
> >>> ExecutionEngine/Orc/LazyEmittingLayer.h?rev=306166&r1=
> >>> 306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h
> >>> (original)
> >>> > +++ llvm/trunk/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h
> >>> Fri Jun 23 16:45:29 2017
> >>> > @@ -34,19 +34,20 @@ namespace orc {
> >>> >
> >>> > /// @brief Lazy-emitting IR layer.
> >>> > ///
> >>> > -/// This layer accepts sets of LLVM IR Modules (via addModuleSet),
> >>> but does
> >>> > -/// not immediately emit them the layer below. Instead, emissing to
> >>> the base
> >>> > -/// layer is deferred until the first time the client requests the
> >>> address
> >>> > -/// (via JITSymbol::getAddress) for a symbol contained in this
> layer.
> >>> > +/// This layer accepts LLVM IR Modules (via addModule), but does
> not
> >>> > +/// immediately emit them the layer below. Instead, emissing to the
> >>> base layer
> >>> > +/// is deferred until the first time the client requests the address
> >>> (via
> >>> > +/// JITSymbol::getAddress) for a symbol contained in this layer.
> >>> > template <typename BaseLayerT> class LazyEmittingLayer {
> >>> > public:
> >>> > - using BaseLayerHandleT = typename BaseLayerT::ModuleSetHandleT;
> >>> > +
> >>> > + using BaseLayerHandleT = typename BaseLayerT::ModuleHandleT;
> >>> >
> >>> > private:
> >>> > - class EmissionDeferredSet {
> >>> > + class EmissionDeferredModule {
> >>> > public:
> >>> > - EmissionDeferredSet() = default;
> >>> > - virtual ~EmissionDeferredSet() = default;
> >>> > + EmissionDeferredModule() = default;
> >>> > + virtual ~EmissionDeferredModule() = default;
> >>> >
> >>> > JITSymbol find(StringRef Name, bool ExportedSymbolsOnly,
> >>> BaseLayerT &B) {
> >>> > switch (EmitState) {
> >>> > @@ -84,9 +85,9 @@ private:
> >>> > llvm_unreachable("Invalid emit-state.");
> >>> > }
> >>> >
> >>> > - void removeModulesFromBaseLayer(BaseLayerT &BaseLayer) {
> >>> > + void removeModuleFromBaseLayer(BaseLayerT &BaseLayer) {
> >>> > if (EmitState != NotEmitted)
> >>> > - BaseLayer.removeModuleSet(Handle);
> >>> > + BaseLayer.removeModule(Handle);
> >>> > }
> >>> >
> >>> > void emitAndFinalize(BaseLayerT &BaseLayer) {
> >>> > @@ -100,10 +101,9 @@ private:
> >>> > BaseLayer.emitAndFinalize(Handle);
> >>> > }
> >>> >
> >>> > - template <typename ModuleSetT, typename MemoryManagerPtrT,
> >>> > - typename SymbolResolverPtrT>
> >>> > - static std::unique_ptr<EmissionDeferredSet>
> >>> > - create(BaseLayerT &B, ModuleSetT Ms, MemoryManagerPtrT MemMgr,
> >>> > + template <typename MemoryManagerPtrT, typename
> SymbolResolverPtrT>
> >>> > + static std::unique_ptr<EmissionDeferredModule>
> >>> > + create(BaseLayerT &B, std::shared_ptr<Module> M,
> MemoryManagerPtrT
> >>> MemMgr,
> >>> > SymbolResolverPtrT Resolver);
> >>> >
> >>> > protected:
> >>> > @@ -116,14 +116,13 @@ private:
> >>> > BaseLayerHandleT Handle;
> >>> > };
> >>> >
> >>> > - template <typename ModuleSetT, typename MemoryManagerPtrT,
> >>> > - typename SymbolResolverPtrT>
> >>> > - class EmissionDeferredSetImpl : public EmissionDeferredSet {
> >>> > + template <typename MemoryManagerPtrT, typename SymbolResolverPtrT>
> >>> > + class EmissionDeferredModuleImpl : public EmissionDeferredModule {
> >>> > public:
> >>> > - EmissionDeferredSetImpl(ModuleSetT Ms,
> >>> > - MemoryManagerPtrT MemMgr,
> >>> > - SymbolResolverPtrT Resolver)
> >>> > - : Ms(std::move(Ms)), MemMgr(std::move(MemMgr)),
> >>> > + EmissionDeferredModuleImpl(std::shared_ptr<Module> M,
> >>> > + MemoryManagerPtrT MemMgr,
> >>> > + SymbolResolverPtrT Resolver)
> >>> > + : M(std::move(M)), MemMgr(std::move(MemMgr)),
> >>> > Resolver(std::move(Resolver)) {}
> >>> >
> >>> > protected:
> >>> > @@ -154,8 +153,8 @@ private:
> >>> > // We don't need the mangled names set any more: Once we've
> >>> emitted this
> >>> > // to the base layer we'll just look for symbols there.
> >>> > MangledSymbols.reset();
> >>> > - return BaseLayer.addModuleSet(std::move(Ms),
> std::move(MemMgr),
> >>> > - std::move(Resolver));
> >>> > + return BaseLayer.addModule(std::move(M), std::move(MemMgr),
> >>> > + std::move(Resolver));
> >>> > }
> >>> >
> >>> > private:
> >>> > @@ -197,56 +196,54 @@ private:
> >>> >
> >>> > auto Symbols = llvm::make_unique<StringMap<const
> >>> GlobalValue*>>();
> >>> >
> >>> > - for (const auto &M : Ms) {
> >>> > - Mangler Mang;
> >>> > + Mangler Mang;
> >>> >
> >>> > - for (const auto &GO : M->global_objects())
> >>> > + for (const auto &GO : M->global_objects())
> >>> > if (auto GV = addGlobalValue(*Symbols, GO, Mang,
> SearchName,
> >>> > ExportedSymbolsOnly))
> >>> > return GV;
> >>> > - }
> >>> >
> >>> > MangledSymbols = std::move(Symbols);
> >>> > return nullptr;
> >>> > }
> >>> >
> >>> > - ModuleSetT Ms;
> >>> > + std::shared_ptr<Module> M;
> >>> > MemoryManagerPtrT MemMgr;
> >>> > SymbolResolverPtrT Resolver;
> >>> > mutable std::unique_ptr<StringMap<const GlobalValue*>>
> >>> MangledSymbols;
> >>> > };
> >>> >
> >>> > - using ModuleSetListT = std::list<std::unique_ptr<Emis
> >>> sionDeferredSet>>;
> >>> > + using ModuleListT = std::list<std::unique_ptr<Emis
> >>> sionDeferredModule>>;
> >>> >
> >>> > BaseLayerT &BaseLayer;
> >>> > - ModuleSetListT ModuleSetList;
> >>> > + ModuleListT ModuleList;
> >>> >
> >>> > public:
> >>> > - /// @brief Handle to a set of loaded modules.
> >>> > - using ModuleSetHandleT = typename ModuleSetListT::iterator;
> >>> > + /// @brief Handle to a loaded module.
> >>> > + using ModuleHandleT = typename ModuleListT::iterator;
> >>> >
> >>> > /// @brief Construct a lazy emitting layer.
> >>> > LazyEmittingLayer(BaseLayerT &BaseLayer) : BaseLayer(BaseLayer) {}
> >>> >
> >>> > - /// @brief Add the given set of modules to the lazy emitting
> layer.
> >>> > - template <typename ModuleSetT, typename MemoryManagerPtrT,
> >>> > - typename SymbolResolverPtrT>
> >>> > - ModuleSetHandleT addModuleSet(ModuleSetT Ms,
> >>> > - MemoryManagerPtrT MemMgr,
> >>> > - SymbolResolverPtrT Resolver) {
> >>> > - return ModuleSetList.insert(
> >>> > - ModuleSetList.end(),
> >>> > - EmissionDeferredSet::create(BaseLayer, std::move(Ms),
> >>> std::move(MemMgr),
> >>> > - std::move(Resolver)));
> >>> > + /// @brief Add the given module to the lazy emitting layer.
> >>> > + template <typename MemoryManagerPtrT, typename SymbolResolverPtrT>
> >>> > + ModuleHandleT addModule(std::shared_ptr<Module> M,
> >>> > + MemoryManagerPtrT MemMgr,
> >>> > + SymbolResolverPtrT Resolver) {
> >>> > + return ModuleList.insert(
> >>> > + ModuleList.end(),
> >>> > + EmissionDeferredModule::create(BaseLayer, std::move(M),
> >>> > + std::move(MemMgr),
> >>> > + std::move(Resolver)));
> >>> > }
> >>> >
> >>> > - /// @brief Remove the module set represented by the given handle.
> >>> > + /// @brief Remove the module represented by the given handle.
> >>> > ///
> >>> > - /// This method will free the memory associated with the given
> >>> module set,
> >>> > - /// both in this layer, and the base layer.
> >>> > - void removeModuleSet(ModuleSetHandleT H) {
> >>> > - (*H)->removeModulesFromBaseLayer(BaseLayer);
> >>> > - ModuleSetList.erase(H);
> >>> > + /// This method will free the memory associated with the given
> >>> module, both
> >>> > + /// in this layer, and the base layer.
> >>> > + void removeModule(ModuleHandleT H) {
> >>> > + (*H)->removeModuleFromBaseLayer(BaseLayer);
> >>> > + ModuleList.erase(H);
> >>> > }
> >>> >
> >>> > /// @brief Search for the given named symbol.
> >>> > @@ -258,42 +255,40 @@ public:
> >>> > if (auto Symbol = BaseLayer.findSymbol(Name,
> ExportedSymbolsOnly))
> >>> > return Symbol;
> >>> >
> >>> > - // If not found then search the deferred sets. If any of these
> >>> contain a
> >>> > + // If not found then search the deferred modules. If any of
> these
> >>> contain a
> >>> > // definition of 'Name' then they will return a JITSymbol that
> >>> will emit
> >>> > // the corresponding module when the symbol address is
> requested.
> >>> > - for (auto &DeferredSet : ModuleSetList)
> >>> > - if (auto Symbol = DeferredSet->find(Name, ExportedSymbolsOnly,
> >>> BaseLayer))
> >>> > + for (auto &DeferredMod : ModuleList)
> >>> > + if (auto Symbol = DeferredMod->find(Name, ExportedSymbolsOnly,
> >>> BaseLayer))
> >>> > return Symbol;
> >>> >
> >>> > // If no definition found anywhere return a null symbol.
> >>> > return nullptr;
> >>> > }
> >>> >
> >>> > - /// @brief Get the address of the given symbol in the context of
> the
> >>> set of
> >>> > + /// @brief Get the address of the given symbol in the context of
> the
> >>> of
> >>> > /// compiled modules represented by the handle H.
> >>> > - JITSymbol findSymbolIn(ModuleSetHandleT H, const std::string
> &Name,
> >>> > + JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name,
> >>> > bool ExportedSymbolsOnly) {
> >>> > return (*H)->find(Name, ExportedSymbolsOnly, BaseLayer);
> >>> > }
> >>> >
> >>> > - /// @brief Immediately emit and finalize the moduleOB set
> >>> represented by the
> >>> > - /// given handle.
> >>> > - /// @param H Handle for module set to emit/finalize.
> >>> > - void emitAndFinalize(ModuleSetHandleT H) {
> >>> > + /// @brief Immediately emit and finalize the module represented by
> >>> the given
> >>> > + /// handle.
> >>> > + /// @param H Handle for module to emit/finalize.
> >>> > + void emitAndFinalize(ModuleHandleT H) {
> >>> > (*H)->emitAndFinalize(BaseLayer);
> >>> > }
> >>> > };
> >>> >
> >>> > template <typename BaseLayerT>
> >>> > -template <typename ModuleSetT, typename MemoryManagerPtrT,
> >>> > - typename SymbolResolverPtrT>
> >>> > -std::unique_ptr<typename LazyEmittingLayer<BaseLayerT>:
> >>> :EmissionDeferredSet>
> >>> > -LazyEmittingLayer<BaseLayerT>::EmissionDeferredSet::create(
> >>> > - BaseLayerT &B, ModuleSetT Ms, MemoryManagerPtrT MemMgr,
> >>> > +template <typename MemoryManagerPtrT, typename SymbolResolverPtrT>
> >>> > +std::unique_ptr<typename LazyEmittingLayer<BaseLayerT>:
> >>> :EmissionDeferredModule>
> >>> > +LazyEmittingLayer<BaseLayerT>::EmissionDeferredModule::create(
> >>> > + BaseLayerT &B, std::shared_ptr<Module> M, MemoryManagerPtrT
> MemMgr,
> >>> > SymbolResolverPtrT Resolver) {
> >>> > - using EDS = EmissionDeferredSetImpl<ModuleSetT,
> MemoryManagerPtrT,
> >>> > - SymbolResolverPtrT>;
> >>> > - return llvm::make_unique<EDS>(std::move(Ms), std::move(MemMgr),
> >>> > + using EDS = EmissionDeferredModuleImpl<MemoryManagerPtrT,
> >>> SymbolResolverPtrT>;
> >>> > + return llvm::make_unique<EDS>(std::move(M), std::move(MemMgr),
> >>> > std::move(Resolver));
> >>> > }
> >>> >
> >>> >
> >>> > Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindings.cpp
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Execution
> >>> Engine/Orc/OrcCBindings.cpp?rev=306166&r1=306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindings.cpp (original)
> >>> > +++ llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindings.cpp Fri Jun 23
> >>> 16:45:29 2017
> >>> > @@ -12,6 +12,24 @@
> >>> >
> >>> > using namespace llvm;
> >>> >
> >>> > +LLVMSharedModuleRef LLVMOrcMakeSharedModule(LLVMModuleRef Mod) {
> >>> > + return wrap(new std::shared_ptr<Module>(unwrap(Mod)));
> >>> > +}
> >>> > +
> >>> > +void LLVMOrcDisposeSharedModuleRef(LLVMSharedModuleRef SharedMod) {
> >>> > + delete unwrap(SharedMod);
> >>> > +}
> >>> > +
> >>> > +LLVMSharedObjectBufferRef
> >>> > +LLVMOrcMakeSharedObjectBuffer(LLVMMemoryBufferRef ObjBuffer) {
> >>> > + return wrap(new std::shared_ptr<MemoryBuffer>(
> unwrap(ObjBuffer)));
> >>> > +}
> >>> > +
> >>> > +void
> >>> > +LLVMOrcDisposeSharedObjectBufferRef(LLVMSharedObjectBufferRef
> >>> SharedObjBuffer) {
> >>> > + delete unwrap(SharedObjBuffer);
> >>> > +}
> >>> > +
> >>> > LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM) {
> >>> > TargetMachine *TM2(unwrap(TM));
> >>> >
> >>> > @@ -65,21 +83,23 @@ LLVMOrcErrorCode LLVMOrcSetIndirectStubP
> >>> > }
> >>> >
> >>> > LLVMOrcModuleHandle
> >>> > -LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack,
> >>> LLVMModuleRef Mod,
> >>> > +LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack,
> >>> > + LLVMSharedModuleRef Mod,
> >>> > LLVMOrcSymbolResolverFn SymbolResolver,
> >>> > void *SymbolResolverCtx) {
> >>> > OrcCBindingsStack &J = *unwrap(JITStack);
> >>> > - Module *M(unwrap(Mod));
> >>> > - return J.addIRModuleEager(M, SymbolResolver, SymbolResolverCtx);
> >>> > + std::shared_ptr<Module> *M(unwrap(Mod));
> >>> > + return J.addIRModuleEager(*M, SymbolResolver, SymbolResolverCtx);
> >>> > }
> >>> >
> >>> > LLVMOrcModuleHandle
> >>> > -LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack,
> LLVMModuleRef
> >>> Mod,
> >>> > +LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack,
> >>> > + LLVMSharedModuleRef Mod,
> >>> > LLVMOrcSymbolResolverFn SymbolResolver,
> >>> > void *SymbolResolverCtx) {
> >>> > OrcCBindingsStack &J = *unwrap(JITStack);
> >>> > - Module *M(unwrap(Mod));
> >>> > - return J.addIRModuleLazy(M, SymbolResolver, SymbolResolverCtx);
> >>> > + std::shared_ptr<Module> *M(unwrap(Mod));
> >>> > + return J.addIRModuleLazy(*M, SymbolResolver, SymbolResolverCtx);
> >>> > }
> >>> >
> >>> > void LLVMOrcRemoveModule(LLVMOrcJITStackRef JITStack,
> >>> LLVMOrcModuleHandle H) {
> >>> >
> >>> > Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Execution
> >>> Engine/Orc/OrcCBindingsStack.h?rev=306166&r1=306165&r2=
> 306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
> (original)
> >>> > +++ llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h Fri Jun
> 23
> >>> 16:45:29 2017
> >>> > @@ -42,6 +42,10 @@ namespace llvm {
> >>> >
> >>> > class OrcCBindingsStack;
> >>> >
> >>> > +DEFINE_SIMPLE_CONVERSION_FUNCTIONS(std::shared_ptr<Module>,
> >>> > + LLVMSharedModuleRef);
> >>> > +DEFINE_SIMPLE_CONVERSION_FUNCTIONS(std::shared_ptr<MemoryBuffer>,
> >>> > + LLVMSharedObjectBufferRef);
> >>> > DEFINE_SIMPLE_CONVERSION_FUNCTIONS(OrcCBindingsStack,
> >>> LLVMOrcJITStackRef)
> >>> > DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine,
> >>> LLVMTargetMachineRef)
> >>> >
> >>> > @@ -71,7 +75,7 @@ private:
> >>> >
> >>> > template <typename LayerT> class GenericHandleImpl : public
> >>> GenericHandle {
> >>> > public:
> >>> > - GenericHandleImpl(LayerT &Layer, typename
> LayerT::ModuleSetHandleT
> >>> Handle)
> >>> > + GenericHandleImpl(LayerT &Layer, typename LayerT::ModuleHandleT
> >>> Handle)
> >>> > : Layer(Layer), Handle(std::move(Handle)) {}
> >>> >
> >>> > JITSymbol findSymbolIn(const std::string &Name,
> >>> > @@ -79,24 +83,21 @@ private:
> >>> > return Layer.findSymbolIn(Handle, Name, ExportedSymbolsOnly);
> >>> > }
> >>> >
> >>> > - void removeModule() override { return
> >>> Layer.removeModuleSet(Handle); }
> >>> > + void removeModule() override { return
> Layer.removeModule(Handle); }
> >>> >
> >>> > private:
> >>> > LayerT &Layer;
> >>> > - typename LayerT::ModuleSetHandleT Handle;
> >>> > + typename LayerT::ModuleHandleT Handle;
> >>> > };
> >>> >
> >>> > template <typename LayerT>
> >>> > std::unique_ptr<GenericHandleImpl<LayerT>>
> >>> > - createGenericHandle(LayerT &Layer, typename
> LayerT::ModuleSetHandleT
> >>> Handle) {
> >>> > + createGenericHandle(LayerT &Layer, typename LayerT::ModuleHandleT
> >>> Handle) {
> >>> > return llvm::make_unique<GenericHandleImpl<LayerT>>(Layer,
> >>> >
> >>> std::move(Handle));
> >>> > }
> >>> >
> >>> > public:
> >>> > - // We need a 'ModuleSetHandleT' to conform to the layer concept.
> >>> > - using ModuleSetHandleT = unsigned;
> >>> > -
> >>> > using ModuleHandleT = unsigned;
> >>> >
> >>> > OrcCBindingsStack(TargetMachine &TM,
> >>> > @@ -183,7 +184,7 @@ public:
> >>> > }
> >>> >
> >>> > template <typename LayerT>
> >>> > - ModuleHandleT addIRModule(LayerT &Layer, Module *M,
> >>> > + ModuleHandleT addIRModule(LayerT &Layer, std::shared_ptr<Module>
> M,
> >>> > std::unique_ptr<RuntimeDyld::
> MemoryManager>
> >>> MemMgr,
> >>> > LLVMOrcSymbolResolverFn
> ExternalResolver,
> >>> > void *ExternalResolverCtx) {
> >>> > @@ -203,11 +204,8 @@ public:
> >>> > auto Resolver = createResolver(ExternalResolver,
> >>> ExternalResolverCtx);
> >>> >
> >>> > // Add the module to the JIT.
> >>> > - std::vector<Module *> S;
> >>> > - S.push_back(std::move(M));
> >>> > -
> >>> > - auto LH = Layer.addModuleSet(std::move(S), std::move(MemMgr),
> >>> > - std::move(Resolver));
> >>> > + auto LH = Layer.addModule(std::move(M), std::move(MemMgr),
> >>> > + std::move(Resolver));
> >>> > ModuleHandleT H = createHandle(Layer, LH);
> >>> >
> >>> > // Run the static constructors, and save the static destructor
> >>> runner for
> >>> > @@ -220,7 +218,7 @@ public:
> >>> > return H;
> >>> > }
> >>> >
> >>> > - ModuleHandleT addIRModuleEager(Module *M,
> >>> > + ModuleHandleT addIRModuleEager(std::shared_ptr<Module> M,
> >>> > LLVMOrcSymbolResolverFn
> >>> ExternalResolver,
> >>> > void *ExternalResolverCtx) {
> >>> > return addIRModule(CompileLayer, std::move(M),
> >>> > @@ -228,7 +226,7 @@ public:
> >>> > std::move(ExternalResolver),
> >>> ExternalResolverCtx);
> >>> > }
> >>> >
> >>> > - ModuleHandleT addIRModuleLazy(Module *M,
> >>> > + ModuleHandleT addIRModuleLazy(std::shared_ptr<Module> M,
> >>> > LLVMOrcSymbolResolverFn
> >>> ExternalResolver,
> >>> > void *ExternalResolverCtx) {
> >>> > return addIRModule(CODLayer, std::move(M),
> >>> > @@ -257,8 +255,7 @@ public:
> >>> >
> >>> > private:
> >>> > template <typename LayerT>
> >>> > - unsigned createHandle(LayerT &Layer,
> >>> > - typename LayerT::ModuleSetHandleT Handle) {
> >>> > + unsigned createHandle(LayerT &Layer, typename
> LayerT::ModuleHandleT
> >>> Handle) {
> >>> > unsigned NewHandle;
> >>> > if (!FreeHandleIndexes.empty()) {
> >>> > NewHandle = FreeHandleIndexes.back();
> >>> >
> >>> > Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Execution
> >>> Engine/Orc/OrcMCJITReplacement.h?rev=306166&r1=306165&r2=306166&
> view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
> (original)
> >>> > +++ llvm/trunk/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h Fri Jun
> >>> 23 16:45:29 2017
> >>> > @@ -191,10 +191,15 @@ public:
> >>> > } else {
> >>> > assert(M->getDataLayout() == getDataLayout() && "DataLayout
> >>> Mismatch");
> >>> > }
> >>> > - Modules.push_back(std::move(M));
> >>> > - std::vector<Module *> Ms;
> >>> > - Ms.push_back(&*Modules.back());
> >>> > - LazyEmitLayer.addModuleSet(std::move(Ms), &MemMgr, &Resolver);
> >>> > + auto *MPtr = M.release();
> >>> > + Retain[MPtr] = false;
> >>> > + auto Deleter =
> >>> > + [this](Module *Mod) {
> >>> > + if (!Retain[Mod])
> >>> > + delete Mod;
> >>> > + };
> >>> > + LocalModules.push_back(std::shared_ptr<Module>(MPtr,
> >>> std::move(Deleter)));
> >>> > + LazyEmitLayer.addModule(LocalModules.back(), &MemMgr,
> &Resolver);
> >>> > }
> >>> >
> >>> > void addObjectFile(std::unique_ptr<object::ObjectFile> O)
> override {
> >>> > @@ -381,6 +386,8 @@ private:
> >>> > std::map<ObjectLayerT::ObjHandleT, SectionAddrSet,
> ObjHandleCompare>
> >>> > UnfinalizedSections;
> >>> >
> >>> > + std::map<Module*, bool> Retain;
> >>> > + std::vector<std::shared_ptr<Module>> LocalModules;
> >>> > std::vector<object::OwningBinary<object::Archive>> Archives;
> >>> > };
> >>> >
> >>> >
> >>> > Modified: llvm/trunk/tools/lli/OrcLazyJIT.cpp
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/lli/Orc
> >>> LazyJIT.cpp?rev=306166&r1=306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/tools/lli/OrcLazyJIT.cpp (original)
> >>> > +++ llvm/trunk/tools/lli/OrcLazyJIT.cpp Fri Jun 23 16:45:29 2017
> >>> > @@ -54,10 +54,10 @@ static cl::opt<bool> OrcInlineStubs("orc
> >>> > OrcLazyJIT::TransformFtor OrcLazyJIT::createDebugDumper() {
> >>> > switch (OrcDumpKind) {
> >>> > case DumpKind::NoDump:
> >>> > - return [](std::unique_ptr<Module> M) { return M; };
> >>> > + return [](std::shared_ptr<Module> M) { return M; };
> >>> >
> >>> > case DumpKind::DumpFuncsToStdOut:
> >>> > - return [](std::unique_ptr<Module> M) {
> >>> > + return [](std::shared_ptr<Module> M) {
> >>> > printf("[ ");
> >>> >
> >>> > for (const auto &F : *M) {
> >>> > @@ -76,7 +76,7 @@ OrcLazyJIT::TransformFtor OrcLazyJIT::cr
> >>> > };
> >>> >
> >>> > case DumpKind::DumpModsToStdOut:
> >>> > - return [](std::unique_ptr<Module> M) {
> >>> > + return [](std::shared_ptr<Module> M) {
> >>> > outs() << "----- Module Start -----\n" << *M
> >>> > << "----- Module End -----\n";
> >>> >
> >>> > @@ -84,7 +84,7 @@ OrcLazyJIT::TransformFtor OrcLazyJIT::cr
> >>> > };
> >>> >
> >>> > case DumpKind::DumpModsToDisk:
> >>> > - return [](std::unique_ptr<Module> M) {
> >>> > + return [](std::shared_ptr<Module> M) {
> >>> > std::error_code EC;
> >>> > raw_fd_ostream Out(M->getModuleIdentifier() + ".ll",
> EC,
> >>> > sys::fs::F_Text);
> >>> > @@ -147,7 +147,8 @@ int llvm::runOrcLazyJIT(std::vector<std:
> >>> > OrcInlineStubs);
> >>> >
> >>> > // Add the module, look up main and run it.
> >>> > - J.addModuleSet(std::move(Ms));
> >>> > + for (auto &M : Ms)
> >>> > + J.addModule(std::shared_ptr<Module>(std::move(M)));
> >>> > auto MainSym = J.findSymbol("main");
> >>> >
> >>> > if (!MainSym) {
> >>> >
> >>> > Modified: llvm/trunk/tools/lli/OrcLazyJIT.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/lli/Orc
> >>> LazyJIT.h?rev=306166&r1=306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/tools/lli/OrcLazyJIT.h (original)
> >>> > +++ llvm/trunk/tools/lli/OrcLazyJIT.h Fri Jun 23 16:45:29 2017
> >>> > @@ -50,11 +50,11 @@ public:
> >>> > using ObjLayerT = orc::RTDyldObjectLinkingLayer;
> >>> > using CompileLayerT = orc::IRCompileLayer<ObjLayerT,
> >>> orc::SimpleCompiler>;
> >>> > using TransformFtor =
> >>> > - std::function<std::unique_ptr<Module>(std::unique_ptr<
> Module>)>;
> >>> > + std::function<std::shared_ptr<
> Module>(std::shared_ptr<Module
> >>> >)>;
> >>> > using IRDumpLayerT = orc::IRTransformLayer<CompileLayerT,
> >>> TransformFtor>;
> >>> > using CODLayerT = orc::CompileOnDemandLayer<IRDumpLayerT,
> >>> CompileCallbackMgr>;
> >>> > using IndirectStubsManagerBuilder = CODLayerT::IndirectStubsManage
> >>> rBuilderT;
> >>> > - using ModuleSetHandleT = CODLayerT::ModuleSetHandleT;
> >>> > + using ModuleHandleT = CODLayerT::ModuleHandleT;
> >>> >
> >>> > OrcLazyJIT(std::unique_ptr<TargetMachine> TM,
> >>> > std::unique_ptr<CompileCallbackMgr> CCMgr,
> >>> > @@ -77,11 +77,9 @@ public:
> >>> > DtorRunner.runViaLayer(CODLayer);
> >>> > }
> >>> >
> >>> > - ModuleSetHandleT addModuleSet(std::vector<std::
> unique_ptr<Module>>
> >>> Ms) {
> >>> > - // Attach a data-layouts if they aren't already present.
> >>> > - for (auto &M : Ms)
> >>> > - if (M->getDataLayout().isDefault())
> >>> > - M->setDataLayout(DL);
> >>> > + void addModule(std::shared_ptr<Module> M) {
> >>> > + if (M->getDataLayout().isDefault())
> >>> > + M->setDataLayout(DL);
> >>> >
> >>> > // Rename, bump linkage and record static constructors and
> >>> destructors.
> >>> > // We have to do this before we hand over ownership of the
> module
> >>> to the
> >>> > @@ -89,21 +87,19 @@ public:
> >>> > std::vector<std::string> CtorNames, DtorNames;
> >>> > {
> >>> > unsigned CtorId = 0, DtorId = 0;
> >>> > - for (auto &M : Ms) {
> >>> > - for (auto Ctor : orc::getConstructors(*M)) {
> >>> > - std::string NewCtorName = ("$static_ctor." +
> >>> Twine(CtorId++)).str();
> >>> > - Ctor.Func->setName(NewCtorName);
> >>> > - Ctor.Func->setLinkage(GlobalValue::ExternalLinkage);
> >>> > - Ctor.Func->setVisibility(GlobalValue::HiddenVisibility);
> >>> > - CtorNames.push_back(mangle(NewCtorName));
> >>> > - }
> >>> > - for (auto Dtor : orc::getDestructors(*M)) {
> >>> > - std::string NewDtorName = ("$static_dtor." +
> >>> Twine(DtorId++)).str();
> >>> > - Dtor.Func->setLinkage(GlobalValue::ExternalLinkage);
> >>> > - Dtor.Func->setVisibility(GlobalValue::HiddenVisibility);
> >>> > - DtorNames.push_back(mangle(Dtor.Func->getName()));
> >>> > - Dtor.Func->setName(NewDtorName);
> >>> > - }
> >>> > + for (auto Ctor : orc::getConstructors(*M)) {
> >>> > + std::string NewCtorName = ("$static_ctor." +
> >>> Twine(CtorId++)).str();
> >>> > + Ctor.Func->setName(NewCtorName);
> >>> > + Ctor.Func->setLinkage(GlobalValue::ExternalLinkage);
> >>> > + Ctor.Func->setVisibility(GlobalValue::HiddenVisibility);
> >>> > + CtorNames.push_back(mangle(NewCtorName));
> >>> > + }
> >>> > + for (auto Dtor : orc::getDestructors(*M)) {
> >>> > + std::string NewDtorName = ("$static_dtor." +
> >>> Twine(DtorId++)).str();
> >>> > + Dtor.Func->setLinkage(GlobalValue::ExternalLinkage);
> >>> > + Dtor.Func->setVisibility(GlobalValue::HiddenVisibility);
> >>> > + DtorNames.push_back(mangle(Dtor.Func->getName()));
> >>> > + Dtor.Func->setName(NewDtorName);
> >>> > }
> >>> > }
> >>> >
> >>> > @@ -111,41 +107,45 @@ public:
> >>> > // 1) Search the JIT symbols.
> >>> > // 2) Check for C++ runtime overrides.
> >>> > // 3) Search the host process (LLI)'s symbol table.
> >>> > - auto Resolver =
> >>> > - orc::createLambdaResolver(
> >>> > - [this](const std::string &Name) -> JITSymbol {
> >>> > - if (auto Sym = CODLayer.findSymbol(Name, true))
> >>> > - return Sym;
> >>> > - return CXXRuntimeOverrides.searchOverrides(Name);
> >>> > - },
> >>> > - [](const std::string &Name) {
> >>> > - if (auto Addr =
> >>> > - RTDyldMemoryManager::getSymbolAddressInProcess(Name))
> >>> > - return JITSymbol(Addr, JITSymbolFlags::Exported);
> >>> > - return JITSymbol(nullptr);
> >>> > - }
> >>> > - );
> >>> > -
> >>> > - // Add the module to the JIT.
> >>> > - auto H = CODLayer.addModuleSet(std::move(Ms),
> >>> > - llvm::make_unique<SectionMemor
> >>> yManager>(),
> >>> > - std::move(Resolver));
> >>> > + if (ModulesHandle == CODLayerT::ModuleHandleT()) {
> >>> > + auto Resolver =
> >>> > + orc::createLambdaResolver(
> >>> > + [this](const std::string &Name) -> JITSymbol {
> >>> > + if (auto Sym = CODLayer.findSymbol(Name, true))
> >>> > + return Sym;
> >>> > + return CXXRuntimeOverrides.searchOverrides(Name);
> >>> > + },
> >>> > + [](const std::string &Name) {
> >>> > + if (auto Addr =
> >>> > + RTDyldMemoryManager::getSymbolAddressInProcess(
> Name))
> >>> > + return JITSymbol(Addr, JITSymbolFlags::Exported);
> >>> > + return JITSymbol(nullptr);
> >>> > + }
> >>> > + );
> >>> > +
> >>> > + // Add the module to the JIT.
> >>> > + ModulesHandle =
> >>> > + CODLayer.addModule(std::move(M),
> >>> > + llvm::make_unique<
> SectionMemoryManager>(),
> >>> > + std::move(Resolver));
> >>> > + } else
> >>> > + CODLayer.addExtraModule(ModulesHandle, std::move(M));
> >>> >
> >>> > // Run the static constructors, and save the static destructor
> >>> runner for
> >>> > // execution when the JIT is torn down.
> >>> > - orc::CtorDtorRunner<CODLayerT> CtorRunner(std::move(CtorNames),
> >>> H);
> >>> > + orc::CtorDtorRunner<CODLayerT> CtorRunner(std::move(CtorNames),
> >>> > + ModulesHandle);
> >>> > CtorRunner.runViaLayer(CODLayer);
> >>> >
> >>> > - IRStaticDestructorRunners.emplace_back(std::move(DtorNames),
> H);
> >>> > -
> >>> > - return H;
> >>> > + IRStaticDestructorRunners.emplace_back(std::move(DtorNames),
> >>> > + ModulesHandle);
> >>> > }
> >>> >
> >>> > JITSymbol findSymbol(const std::string &Name) {
> >>> > return CODLayer.findSymbol(mangle(Name), true);
> >>> > }
> >>> >
> >>> > - JITSymbol findSymbolIn(ModuleSetHandleT H, const std::string
> &Name) {
> >>> > + JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name) {
> >>> > return CODLayer.findSymbolIn(H, mangle(Name), true);
> >>> > }
> >>> >
> >>> > @@ -179,6 +179,7 @@ private:
> >>> >
> >>> > orc::LocalCXXRuntimeOverrides CXXRuntimeOverrides;
> >>> > std::vector<orc::CtorDtorRunner<CODLayerT>>
> >>> IRStaticDestructorRunners;
> >>> > + CODLayerT::ModuleHandleT ModulesHandle;
> >>> > };
> >>> >
> >>> > int runOrcLazyJIT(std::vector<std::unique_ptr<Module>> Ms,
> >>> >
> >>> > Modified: llvm/trunk/unittests/ExecutionEngine/Orc/
> LazyEmittingLayerTe
> >>> st.cpp
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Exe
> >>> cutionEngine/Orc/LazyEmittingLayerTest.cpp?rev=306166&r1=
> >>> 306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/unittests/ExecutionEngine/Orc/
> LazyEmittingLayerTest.cpp
> >>> (original)
> >>> > +++ llvm/trunk/unittests/ExecutionEngine/Orc/
> LazyEmittingLayerTest.cpp
> >>> Fri Jun 23 16:45:29 2017
> >>> > @@ -14,9 +14,9 @@
> >>> > namespace {
> >>> >
> >>> > struct MockBaseLayer {
> >>> > - typedef int ModuleSetHandleT;
> >>> > - ModuleSetHandleT addModuleSet(
> >>> > - std::list<std::unique_ptr<llvm::Module>>,
> >>> > + typedef int ModuleHandleT;
> >>> > + ModuleHandleT addModule(
> >>> > + std::shared_ptr<llvm::Module>,
> >>> > std::unique_ptr<llvm::RuntimeDyld::MemoryManager>
> >>> MemMgr,
> >>> > std::unique_ptr<llvm::JITSymbolResolver>
> Resolver) {
> >>> > EXPECT_FALSE(MemMgr);
> >>> > @@ -27,7 +27,7 @@ struct MockBaseLayer {
> >>> > TEST(LazyEmittingLayerTest, Empty) {
> >>> > MockBaseLayer M;
> >>> > llvm::orc::LazyEmittingLayer<MockBaseLayer> L(M);
> >>> > - L.addModuleSet(std::list<std::unique_ptr<llvm::Module>>(),
> nullptr,
> >>> nullptr);
> >>> > + L.addModule(std::unique_ptr<llvm::Module>(), nullptr, nullptr);
> >>> > }
> >>> >
> >>> > }
> >>> >
> >>> > Modified: llvm/trunk/unittests/ExecutionEngine/Orc/
> ObjectTransformLaye
> >>> rTest.cpp
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Exe
> >>> cutionEngine/Orc/ObjectTransformLayerTest.cpp?rev=306166&r1=
> >>> 306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/unittests/ExecutionEngine/Orc/
> ObjectTransformLayerTest.cpp
> >>> (original)
> >>> > +++ llvm/trunk/unittests/ExecutionEngine/Orc/
> ObjectTransformLayerTest.cpp
> >>> Fri Jun 23 16:45:29 2017
> >>> > @@ -314,7 +314,7 @@ TEST(ObjectTransformLayerTest, Main) {
> >>> > // compile.
> >>> > NullResolver Resolver;
> >>> > NullManager Manager;
> >>> > - CompileLayer.addModuleSet(std::vector<llvm::Module *>(),
> &Manager,
> >>> &Resolver);
> >>> > + CompileLayer.addModule(std::shared_ptr<llvm::Module>(), &Manager,
> >>> &Resolver);
> >>> >
> >>> > // Make sure that the calls from ObjectTransformLayer to
> >>> ObjectLinkingLayer
> >>> > // compile.
> >>> >
> >>> > Modified: llvm/trunk/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Exe
> >>> cutionEngine/Orc/OrcCAPITest.cpp?rev=306166&r1=306165&r2=
> 306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp
> (original)
> >>> > +++ llvm/trunk/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp Fri Jun
> >>> 23 16:45:29 2017
> >>> > @@ -65,8 +65,9 @@ protected:
> >>> > CompileContext *CCtx = static_cast<CompileContext*>(Ctx);
> >>> > auto *ET = CCtx->APIExecTest;
> >>> > CCtx->M = ET->createTestModule(ET->TM->getTargetTriple());
> >>> > - CCtx->H = LLVMOrcAddEagerlyCompiledIR(JITStack,
> >>> wrap(CCtx->M.get()),
> >>> > - myResolver, nullptr);
> >>> > + LLVMSharedModuleRef SM = LLVMOrcMakeSharedModule(wrap(C
> >>> Ctx->M.release()));
> >>> > + CCtx->H = LLVMOrcAddEagerlyCompiledIR(JITStack, SM, myResolver,
> >>> nullptr);
> >>> > + LLVMOrcDisposeSharedModuleRef(SM);
> >>> > CCtx->Compiled = true;
> >>> > LLVMOrcTargetAddress MainAddr = LLVMOrcGetSymbolAddress(
> JITStack,
> >>> "main");
> >>> > LLVMOrcSetIndirectStubPointer(JITStack, "foo", MainAddr);
> >>> > @@ -87,8 +88,10 @@ TEST_F(OrcCAPIExecutionTest, TestEagerIR
> >>> >
> >>> > LLVMOrcGetMangledSymbol(JIT, &testFuncName, "testFunc");
> >>> >
> >>> > + LLVMSharedModuleRef SM = LLVMOrcMakeSharedModule(wrap(
> M.release()));
> >>> > LLVMOrcModuleHandle H =
> >>> > - LLVMOrcAddEagerlyCompiledIR(JIT, wrap(M.get()), myResolver,
> >>> nullptr);
> >>> > + LLVMOrcAddEagerlyCompiledIR(JIT, SM, myResolver, nullptr);
> >>> > + LLVMOrcDisposeSharedModuleRef(SM);
> >>> > MainFnTy MainFn = (MainFnTy)LLVMOrcGetSymbolAddress(JIT, "main");
> >>> > int Result = MainFn();
> >>> > EXPECT_EQ(Result, 42)
> >>> > @@ -111,8 +114,10 @@ TEST_F(OrcCAPIExecutionTest, TestLazyIRC
> >>> >
> >>> > LLVMOrcGetMangledSymbol(JIT, &testFuncName, "testFunc");
> >>> >
> >>> > + LLVMSharedModuleRef SM = LLVMOrcMakeSharedModule(wrap(
> M.release()));
> >>> > LLVMOrcModuleHandle H =
> >>> > - LLVMOrcAddLazilyCompiledIR(JIT, wrap(M.get()), myResolver,
> >>> nullptr);
> >>> > + LLVMOrcAddLazilyCompiledIR(JIT, SM, myResolver, nullptr);
> >>> > + LLVMOrcDisposeSharedModuleRef(SM);
> >>> > MainFnTy MainFn = (MainFnTy)LLVMOrcGetSymbolAddress(JIT, "main");
> >>> > int Result = MainFn();
> >>> > EXPECT_EQ(Result, 42)
> >>> >
> >>> > Modified: llvm/trunk/unittests/ExecutionEngine/Orc/OrcTestCommon.h
> >>> > URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Exe
> >>> cutionEngine/Orc/OrcTestCommon.h?rev=306166&r1=
> 306165&r2=306166&view=diff
> >>> > ============================================================
> >>> ==================
> >>> > --- llvm/trunk/unittests/ExecutionEngine/Orc/OrcTestCommon.h
> (original)
> >>> > +++ llvm/trunk/unittests/ExecutionEngine/Orc/OrcTestCommon.h Fri Jun
> >>> 23 16:45:29 2017
> >>> > @@ -106,65 +106,65 @@ public:
> >>> > };
> >>> >
> >>> > template <typename HandleT,
> >>> > - typename AddModuleSetFtor,
> >>> > - typename RemoveModuleSetFtor,
> >>> > + typename AddModuleFtor,
> >>> > + typename RemoveModuleFtor,
> >>> > typename FindSymbolFtor,
> >>> > typename FindSymbolInFtor>
> >>> > class MockBaseLayer {
> >>> > public:
> >>> >
> >>> > - typedef HandleT ModuleSetHandleT;
> >>> > + typedef HandleT ModuleHandleT;
> >>> >
> >>> > - MockBaseLayer(AddModuleSetFtor &&AddModuleSet,
> >>> > - RemoveModuleSetFtor &&RemoveModuleSet,
> >>> > + MockBaseLayer(AddModuleFtor &&AddModule,
> >>> > + RemoveModuleFtor &&RemoveModule,
> >>> > FindSymbolFtor &&FindSymbol,
> >>> > FindSymbolInFtor &&FindSymbolIn)
> >>> > - : AddModuleSet(AddModuleSet), RemoveModuleSet(
> RemoveModuleSet),
> >>> > + : AddModule(AddModule), RemoveModule(RemoveModule),
> >>> > FindSymbol(FindSymbol), FindSymbolIn(FindSymbolIn)
> >>> > {}
> >>> >
> >>> > - template <typename ModuleSetT, typename MemoryManagerPtrT,
> >>> > + template <typename ModuleT, typename MemoryManagerPtrT,
> >>> > typename SymbolResolverPtrT>
> >>> > - ModuleSetHandleT addModuleSet(ModuleSetT Ms, MemoryManagerPtrT
> >>> MemMgr,
> >>> > - SymbolResolverPtrT Resolver) {
> >>> > - return AddModuleSet(std::move(Ms), std::move(MemMgr),
> >>> std::move(Resolver));
> >>> > + ModuleHandleT addModule(ModuleT Ms, MemoryManagerPtrT MemMgr,
> >>> > + SymbolResolverPtrT Resolver) {
> >>> > + return AddModule(std::move(Ms), std::move(MemMgr),
> >>> std::move(Resolver));
> >>> > }
> >>> >
> >>> > - void removeModuleSet(ModuleSetHandleT H) {
> >>> > - RemoveModuleSet(H);
> >>> > + void removeModule(ModuleHandleT H) {
> >>> > + RemoveModule(H);
> >>> > }
> >>> >
> >>> > JITSymbol findSymbol(const std::string &Name, bool
> >>> ExportedSymbolsOnly) {
> >>> > return FindSymbol(Name, ExportedSymbolsOnly);
> >>> > }
> >>> >
> >>> > - JITSymbol findSymbolIn(ModuleSetHandleT H, const std::string
> &Name,
> >>> > + JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name,
> >>> > bool ExportedSymbolsOnly) {
> >>> > return FindSymbolIn(H, Name, ExportedSymbolsOnly);
> >>> > }
> >>> >
> >>> > private:
> >>> > - AddModuleSetFtor AddModuleSet;
> >>> > - RemoveModuleSetFtor RemoveModuleSet;
> >>> > + AddModuleFtor AddModule;
> >>> > + RemoveModuleFtor RemoveModule;
> >>> > FindSymbolFtor FindSymbol;
> >>> > FindSymbolInFtor FindSymbolIn;
> >>> > };
> >>> >
> >>> > -template <typename ModuleSetHandleT,
> >>> > - typename AddModuleSetFtor,
> >>> > - typename RemoveModuleSetFtor,
> >>> > +template <typename ModuleHandleT,
> >>> > + typename AddModuleFtor,
> >>> > + typename RemoveModuleFtor,
> >>> > typename FindSymbolFtor,
> >>> > typename FindSymbolInFtor>
> >>> > -MockBaseLayer<ModuleSetHandleT, AddModuleSetFtor,
> RemoveModuleSetFtor,
> >>> > +MockBaseLayer<ModuleHandleT, AddModuleFtor, RemoveModuleFtor,
> >>> > FindSymbolFtor, FindSymbolInFtor>
> >>> > -createMockBaseLayer(AddModuleSetFtor &&AddModuleSet,
> >>> > - RemoveModuleSetFtor &&RemoveModuleSet,
> >>> > +createMockBaseLayer(AddModuleFtor &&AddModule,
> >>> > + RemoveModuleFtor &&RemoveModule,
> >>> > FindSymbolFtor &&FindSymbol,
> >>> > FindSymbolInFtor &&FindSymbolIn) {
> >>> > - return MockBaseLayer<ModuleSetHandleT, AddModuleSetFtor,
> >>> RemoveModuleSetFtor,
> >>> > + return MockBaseLayer<ModuleHandleT, AddModuleFtor,
> RemoveModuleFtor,
> >>> > FindSymbolFtor, FindSymbolInFtor>(
> >>> > - std::forward<AddModuleSetFtor>
> (AddModuleSet),
> >>> > - std::forward<RemoveModuleSetF
> >>> tor>(RemoveModuleSet),
> >>> > + std::forward<AddModuleFtor>(AddModule),
> >>> > + std::forward<RemoveModuleFtor>
> (RemoveModule),
> >>> > std::forward<FindSymbolFtor>(FindSymbol),
> >>> > std::forward<FindSymbolInFtor>(
> >>> FindSymbolIn));
> >>> > }
> >>> >
> >>> >
> >>> > _______________________________________________
> >>> > llvm-commits mailing list
> >>> > llvm-commits at lists.llvm.org
> >>> > http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
> >>>
> >>
> >>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20170623/67ec4232/attachment-0001.html>
More information about the llvm-commits
mailing list