[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 16:07:12 PDT 2017


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/06cdfa97/attachment.html>


More information about the llvm-commits mailing list