From 0976cee8e9d6dbf890cb25299baac973307e2d9a Mon Sep 17 00:00:00 2001 From: Lang Hames Date: Fri, 9 Feb 2018 02:30:40 +0000 Subject: [ORC] Remove Layer handles from the layer concept. Handles were returned by addModule and used as keys for removeModule, findSymbolIn, and emitAndFinalize. Their job is now subsumed by VModuleKeys, which simplify resource management by providing a consistent handle across all layers. llvm-svn: 324700 --- llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h | 144 ++++++++------------- llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h | 17 +-- 2 files changed, 56 insertions(+), 105 deletions(-) (limited to 'llvm/lib/ExecutionEngine') diff --git a/llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h b/llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h index 049222db79c..22b618931e3 100644 --- a/llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h +++ b/llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h @@ -33,6 +33,7 @@ #include #include #include +#include #include #include #include @@ -49,75 +50,56 @@ DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef) namespace detail { +// FIXME: Kill this off once the Layer concept becomes an interface. +class GenericLayer { +public: + virtual ~GenericLayer() = default; - class GenericHandle { - public: - GenericHandle(orc::VModuleKey K) : K(K) {} - - virtual ~GenericHandle() = default; - - virtual JITSymbol findSymbolIn(const std::string &Name, - bool ExportedSymbolsOnly) = 0; - virtual Error removeModule(orc::ExecutionSession &ES) = 0; - - orc::VModuleKey K; + virtual JITSymbol findSymbolIn(orc::VModuleKey K, const std::string &Name, + bool ExportedSymbolsOnly) = 0; + virtual Error removeModule(orc::VModuleKey K) = 0; }; - template class GenericHandleImpl : public GenericHandle { + template class GenericLayerImpl : public GenericLayer { public: - GenericHandleImpl(LayerT &Layer, typename LayerT::ModuleHandleT Handle, - orc::VModuleKey K) - : GenericHandle(std::move(K)), Layer(Layer), Handle(std::move(Handle)) { - } + GenericLayerImpl(LayerT &Layer) : Layer(Layer) {} - JITSymbol findSymbolIn(const std::string &Name, + JITSymbol findSymbolIn(orc::VModuleKey K, const std::string &Name, bool ExportedSymbolsOnly) override { - return Layer.findSymbolIn(Handle, Name, ExportedSymbolsOnly); + return Layer.findSymbolIn(K, Name, ExportedSymbolsOnly); } - Error removeModule(orc::ExecutionSession &ES) override { - auto Err = Layer.removeModule(Handle); - ES.releaseVModule(K); - return Err; + Error removeModule(orc::VModuleKey K) override { + return Layer.removeModule(K); } private: LayerT &Layer; - typename LayerT::ModuleHandleT Handle; }; template <> - class GenericHandleImpl - : public GenericHandle { + class GenericLayerImpl : public GenericLayer { private: using LayerT = orc::RTDyldObjectLinkingLayer; public: - GenericHandleImpl(LayerT &Layer, typename LayerT::ObjHandleT Handle, - orc::VModuleKey K) - : GenericHandle(std::move(K)), Layer(Layer), Handle(std::move(Handle)) { - } + GenericLayerImpl(LayerT &Layer) : Layer(Layer) {} - JITSymbol findSymbolIn(const std::string &Name, + JITSymbol findSymbolIn(orc::VModuleKey K, const std::string &Name, bool ExportedSymbolsOnly) override { - return Layer.findSymbolIn(Handle, Name, ExportedSymbolsOnly); + return Layer.findSymbolIn(K, Name, ExportedSymbolsOnly); } - Error removeModule(orc::ExecutionSession &ES) override { - auto Err = Layer.removeObject(Handle); - ES.releaseVModule(K); - return Err; + Error removeModule(orc::VModuleKey K) override { + return Layer.removeObject(K); } private: LayerT &Layer; - typename LayerT::ObjHandleT Handle; }; - template - std::unique_ptr> - createGenericHandle(LayerT &Layer, HandleT Handle, orc::VModuleKey K) { - return llvm::make_unique>( - Layer, std::move(Handle), std::move(K)); + template + std::unique_ptr> createGenericLayer(LayerT &Layer) { + return llvm::make_unique>(Layer); } } // end namespace detail @@ -215,7 +197,6 @@ private: }; public: - using ModuleHandleT = unsigned; OrcCBindingsStack(TargetMachine &TM, std::unique_ptr CCMgr, @@ -304,8 +285,7 @@ public: } template LLVMOrcErrorCode - addIRModule(ModuleHandleT &RetHandle, LayerT &Layer, - std::shared_ptr M, + addIRModule(orc::VModuleKey &RetKey, LayerT &Layer, std::shared_ptr M, std::unique_ptr MemMgr, LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx) { @@ -323,54 +303,54 @@ public: DtorNames.push_back(mangle(Dtor.Func->getName())); // Add the module to the JIT. - ModuleHandleT H; - orc::VModuleKey K = ES.allocateVModule(); - Resolvers[K] = std::make_shared(*this, ExternalResolver, - ExternalResolverCtx); - if (auto LHOrErr = Layer.addModule(K, std::move(M))) - H = createHandle(Layer, *LHOrErr, K); - else - return mapError(LHOrErr.takeError()); + RetKey = ES.allocateVModule(); + Resolvers[RetKey] = std::make_shared( + *this, ExternalResolver, ExternalResolverCtx); + if (auto Err = Layer.addModule(RetKey, std::move(M))) + return mapError(std::move(Err)); + + KeyLayers[RetKey] = detail::createGenericLayer(Layer); // Run the static constructors, and save the static destructor runner for // execution when the JIT is torn down. - orc::CtorDtorRunner CtorRunner(std::move(CtorNames), H); + orc::CtorDtorRunner CtorRunner(std::move(CtorNames), + RetKey); if (auto Err = CtorRunner.runViaLayer(*this)) return mapError(std::move(Err)); - IRStaticDestructorRunners.emplace_back(std::move(DtorNames), H); + IRStaticDestructorRunners.emplace_back(std::move(DtorNames), RetKey); - RetHandle = H; return LLVMOrcErrSuccess; } - LLVMOrcErrorCode addIRModuleEager(ModuleHandleT &RetHandle, + LLVMOrcErrorCode addIRModuleEager(orc::VModuleKey &RetKey, std::shared_ptr M, LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx) { - return addIRModule(RetHandle, CompileLayer, std::move(M), + return addIRModule(RetKey, CompileLayer, std::move(M), llvm::make_unique(), std::move(ExternalResolver), ExternalResolverCtx); } - LLVMOrcErrorCode addIRModuleLazy(ModuleHandleT &RetHandle, + LLVMOrcErrorCode addIRModuleLazy(orc::VModuleKey &RetKey, std::shared_ptr M, LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx) { - return addIRModule(RetHandle, CODLayer, std::move(M), + return addIRModule(RetKey, CODLayer, std::move(M), llvm::make_unique(), std::move(ExternalResolver), ExternalResolverCtx); } - LLVMOrcErrorCode removeModule(ModuleHandleT H) { - if (auto Err = GenericHandles[H]->removeModule(ES)) + LLVMOrcErrorCode removeModule(orc::VModuleKey K) { + // FIXME: Should error release the module key? + if (auto Err = KeyLayers[K]->removeModule(K)) return mapError(std::move(Err)); - GenericHandles[H] = nullptr; - FreeHandleIndexes.push_back(H); + ES.releaseVModule(K); + KeyLayers.erase(K); return LLVMOrcErrSuccess; } - LLVMOrcErrorCode addObject(ModuleHandleT &RetHandle, + LLVMOrcErrorCode addObject(orc::VModuleKey &RetKey, std::unique_ptr ObjBuffer, LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx) { @@ -380,17 +360,14 @@ public: auto OwningObj = std::make_shared(std::move(Obj), std::move(ObjBuffer)); - orc::VModuleKey K = ES.allocateVModule(); - Resolvers[K] = std::make_shared( + RetKey = ES.allocateVModule(); + Resolvers[RetKey] = std::make_shared( *this, ExternalResolver, ExternalResolverCtx); - ModuleHandleT H; - if (auto HOrErr = ObjectLayer.addObject(K, std::move(OwningObj))) - H = createHandle(ObjectLayer, *HOrErr, K); - else - return mapError(HOrErr.takeError()); + if (auto Err = ObjectLayer.addObject(RetKey, std::move(OwningObj))) + return mapError(std::move(Err)); - RetHandle = H; + KeyLayers[RetKey] = detail::createGenericLayer(ObjectLayer); return LLVMOrcErrSuccess; } else @@ -404,9 +381,9 @@ public: return CODLayer.findSymbol(mangle(Name), ExportedSymbolsOnly); } - JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name, + JITSymbol findSymbolIn(orc::VModuleKey K, const std::string &Name, bool ExportedSymbolsOnly) { - return GenericHandles[H]->findSymbolIn(Name, ExportedSymbolsOnly); + return KeyLayers[K]->findSymbolIn(K, Name, ExportedSymbolsOnly); } LLVMOrcErrorCode findSymbolAddress(JITTargetAddress &RetAddr, @@ -432,22 +409,6 @@ public: const std::string &getErrorMessage() const { return ErrMsg; } private: - template - unsigned createHandle(LayerT &Layer, HandleT Handle, orc::VModuleKey K) { - unsigned NewHandle; - if (!FreeHandleIndexes.empty()) { - NewHandle = FreeHandleIndexes.back(); - FreeHandleIndexes.pop_back(); - GenericHandles[NewHandle] = - detail::createGenericHandle(Layer, std::move(Handle), std::move(K)); - return NewHandle; - } else { - NewHandle = GenericHandles.size(); - GenericHandles.push_back( - detail::createGenericHandle(Layer, std::move(Handle), std::move(K))); - } - return NewHandle; - } LLVMOrcErrorCode mapError(Error Err) { LLVMOrcErrorCode Result = LLVMOrcErrSuccess; @@ -479,8 +440,7 @@ private: CompileLayerT CompileLayer; CODLayerT CODLayer; - std::vector> GenericHandles; - std::vector FreeHandleIndexes; + std::map> KeyLayers; orc::LocalCXXRuntimeOverrides CXXRuntimeOverrides; std::vector> IRStaticDestructorRunners; diff --git a/llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h b/llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h index cc5a8a5c1ce..f024674cafe 100644 --- a/llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h +++ b/llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h @@ -393,10 +393,10 @@ private: NotifyObjectLoadedT(OrcMCJITReplacement &M) : M(M) {} - void operator()(RTDyldObjectLinkingLayerBase::ObjHandleT H, + void operator()(VModuleKey K, const RTDyldObjectLinkingLayer::ObjectPtr &Obj, const RuntimeDyld::LoadedObjectInfo &Info) const { - M.UnfinalizedSections[H] = std::move(M.SectionsAllocatedSinceLastLoad); + M.UnfinalizedSections[K] = std::move(M.SectionsAllocatedSinceLastLoad); M.SectionsAllocatedSinceLastLoad = SectionAddrSet(); M.MemMgr->notifyObjectLoaded(&M, *Obj->getBinary()); } @@ -408,9 +408,7 @@ private: public: NotifyFinalizedT(OrcMCJITReplacement &M) : M(M) {} - void operator()(RTDyldObjectLinkingLayerBase::ObjHandleT H) { - M.UnfinalizedSections.erase(H); - } + void operator()(VModuleKey K) { M.UnfinalizedSections.erase(K); } private: OrcMCJITReplacement &M; @@ -455,15 +453,8 @@ private: // that have been emitted but not yet finalized so that we can forward the // mapSectionAddress calls appropriately. using SectionAddrSet = std::set; - struct ObjHandleCompare { - bool operator()(ObjectLayerT::ObjHandleT H1, - ObjectLayerT::ObjHandleT H2) const { - return &*H1 < &*H2; - } - }; SectionAddrSet SectionsAllocatedSinceLastLoad; - std::map - UnfinalizedSections; + std::map UnfinalizedSections; std::vector> Archives; }; -- cgit v1.2.3