1321369Sdim//===- OrcCBindingsStack.h - Orc JIT stack for C bindings -----*- C++ -*---===// 2292915Sdim// 3353358Sdim// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4353358Sdim// See https://llvm.org/LICENSE.txt for license information. 5353358Sdim// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6292915Sdim// 7292915Sdim//===----------------------------------------------------------------------===// 8292915Sdim 9292915Sdim#ifndef LLVM_LIB_EXECUTIONENGINE_ORC_ORCCBINDINGSSTACK_H 10292915Sdim#define LLVM_LIB_EXECUTIONENGINE_ORC_ORCCBINDINGSSTACK_H 11292915Sdim 12309124Sdim#include "llvm-c/OrcBindings.h" 13321369Sdim#include "llvm-c/TargetMachine.h" 14321369Sdim#include "llvm/ADT/STLExtras.h" 15321369Sdim#include "llvm/ADT/StringRef.h" 16321369Sdim#include "llvm/ExecutionEngine/JITSymbol.h" 17341825Sdim#include "llvm/ExecutionEngine/JITEventListener.h" 18292915Sdim#include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h" 19292915Sdim#include "llvm/ExecutionEngine/Orc/CompileUtils.h" 20292915Sdim#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h" 21292915Sdim#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h" 22321369Sdim#include "llvm/ExecutionEngine/Orc/LambdaResolver.h" 23321369Sdim#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h" 24321369Sdim#include "llvm/ExecutionEngine/RuntimeDyld.h" 25321369Sdim#include "llvm/ExecutionEngine/SectionMemoryManager.h" 26321369Sdim#include "llvm/IR/DataLayout.h" 27321369Sdim#include "llvm/IR/Mangler.h" 28321369Sdim#include "llvm/IR/Module.h" 29321369Sdim#include "llvm/Support/CBindingWrapping.h" 30309124Sdim#include "llvm/Support/Error.h" 31321369Sdim#include "llvm/Support/raw_ostream.h" 32321369Sdim#include "llvm/Target/TargetMachine.h" 33321369Sdim#include <algorithm> 34321369Sdim#include <cstdint> 35321369Sdim#include <functional> 36341825Sdim#include <map> 37321369Sdim#include <memory> 38321369Sdim#include <set> 39321369Sdim#include <string> 40321369Sdim#include <vector> 41292915Sdim 42292915Sdimnamespace llvm { 43292915Sdim 44292915Sdimclass OrcCBindingsStack; 45292915Sdim 46292915SdimDEFINE_SIMPLE_CONVERSION_FUNCTIONS(OrcCBindingsStack, LLVMOrcJITStackRef) 47292915SdimDEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef) 48292915Sdim 49327952Sdimnamespace detail { 50292915Sdim 51341825Sdim// FIXME: Kill this off once the Layer concept becomes an interface. 52341825Sdimclass GenericLayer { 53341825Sdimpublic: 54341825Sdim virtual ~GenericLayer() = default; 55292915Sdim 56341825Sdim virtual JITSymbol findSymbolIn(orc::VModuleKey K, const std::string &Name, 57341825Sdim bool ExportedSymbolsOnly) = 0; 58341825Sdim virtual Error removeModule(orc::VModuleKey K) = 0; 59292915Sdim }; 60292915Sdim 61341825Sdim template <typename LayerT> class GenericLayerImpl : public GenericLayer { 62292915Sdim public: 63341825Sdim GenericLayerImpl(LayerT &Layer) : Layer(Layer) {} 64292915Sdim 65341825Sdim JITSymbol findSymbolIn(orc::VModuleKey K, const std::string &Name, 66314564Sdim bool ExportedSymbolsOnly) override { 67341825Sdim return Layer.findSymbolIn(K, Name, ExportedSymbolsOnly); 68292915Sdim } 69292915Sdim 70341825Sdim Error removeModule(orc::VModuleKey K) override { 71341825Sdim return Layer.removeModule(K); 72341825Sdim } 73292915Sdim 74292915Sdim private: 75292915Sdim LayerT &Layer; 76292915Sdim }; 77292915Sdim 78327952Sdim template <> 79344779Sdim class GenericLayerImpl<orc::LegacyRTDyldObjectLinkingLayer> : public GenericLayer { 80327952Sdim private: 81344779Sdim using LayerT = orc::LegacyRTDyldObjectLinkingLayer; 82327952Sdim public: 83341825Sdim GenericLayerImpl(LayerT &Layer) : Layer(Layer) {} 84327952Sdim 85341825Sdim JITSymbol findSymbolIn(orc::VModuleKey K, const std::string &Name, 86327952Sdim bool ExportedSymbolsOnly) override { 87341825Sdim return Layer.findSymbolIn(K, Name, ExportedSymbolsOnly); 88327952Sdim } 89327952Sdim 90341825Sdim Error removeModule(orc::VModuleKey K) override { 91341825Sdim return Layer.removeObject(K); 92341825Sdim } 93327952Sdim 94327952Sdim private: 95327952Sdim LayerT &Layer; 96327952Sdim }; 97327952Sdim 98341825Sdim template <typename LayerT> 99341825Sdim std::unique_ptr<GenericLayerImpl<LayerT>> createGenericLayer(LayerT &Layer) { 100360784Sdim return std::make_unique<GenericLayerImpl<LayerT>>(Layer); 101292915Sdim } 102292915Sdim 103327952Sdim} // end namespace detail 104327952Sdim 105327952Sdimclass OrcCBindingsStack { 106292915Sdimpublic: 107327952Sdim 108327952Sdim using CompileCallbackMgr = orc::JITCompileCallbackManager; 109344779Sdim using ObjLayerT = orc::LegacyRTDyldObjectLinkingLayer; 110344779Sdim using CompileLayerT = orc::LegacyIRCompileLayer<ObjLayerT, orc::SimpleCompiler>; 111327952Sdim using CODLayerT = 112344779Sdim orc::LegacyCompileOnDemandLayer<CompileLayerT, CompileCallbackMgr>; 113327952Sdim 114327952Sdim using CallbackManagerBuilder = 115327952Sdim std::function<std::unique_ptr<CompileCallbackMgr>()>; 116327952Sdim 117327952Sdim using IndirectStubsManagerBuilder = CODLayerT::IndirectStubsManagerBuilderT; 118327952Sdim 119327952Sdimprivate: 120327952Sdim 121327952Sdim using OwningObject = object::OwningBinary<object::ObjectFile>; 122327952Sdim 123341825Sdim class CBindingsResolver : public orc::SymbolResolver { 124341825Sdim public: 125341825Sdim CBindingsResolver(OrcCBindingsStack &Stack, 126341825Sdim LLVMOrcSymbolResolverFn ExternalResolver, 127341825Sdim void *ExternalResolverCtx) 128341825Sdim : Stack(Stack), ExternalResolver(std::move(ExternalResolver)), 129341825Sdim ExternalResolverCtx(std::move(ExternalResolverCtx)) {} 130341825Sdim 131344779Sdim orc::SymbolNameSet 132344779Sdim getResponsibilitySet(const orc::SymbolNameSet &Symbols) override { 133344779Sdim orc::SymbolNameSet Result; 134341825Sdim 135341825Sdim for (auto &S : Symbols) { 136344779Sdim if (auto Sym = findSymbol(*S)) { 137344779Sdim if (!Sym.getFlags().isStrong()) 138344779Sdim Result.insert(S); 139344779Sdim } else if (auto Err = Sym.takeError()) { 140341825Sdim Stack.reportError(std::move(Err)); 141344779Sdim return orc::SymbolNameSet(); 142341825Sdim } 143341825Sdim } 144341825Sdim 145344779Sdim return Result; 146341825Sdim } 147341825Sdim 148341825Sdim orc::SymbolNameSet 149341825Sdim lookup(std::shared_ptr<orc::AsynchronousSymbolQuery> Query, 150341825Sdim orc::SymbolNameSet Symbols) override { 151341825Sdim orc::SymbolNameSet UnresolvedSymbols; 152341825Sdim 153341825Sdim for (auto &S : Symbols) { 154341825Sdim if (auto Sym = findSymbol(*S)) { 155341825Sdim if (auto Addr = Sym.getAddress()) { 156353358Sdim Query->notifySymbolMetRequiredState( 157353358Sdim S, JITEvaluatedSymbol(*Addr, Sym.getFlags())); 158341825Sdim } else { 159341825Sdim Stack.ES.legacyFailQuery(*Query, Addr.takeError()); 160341825Sdim return orc::SymbolNameSet(); 161341825Sdim } 162341825Sdim } else if (auto Err = Sym.takeError()) { 163341825Sdim Stack.ES.legacyFailQuery(*Query, std::move(Err)); 164341825Sdim return orc::SymbolNameSet(); 165341825Sdim } else 166341825Sdim UnresolvedSymbols.insert(S); 167341825Sdim } 168341825Sdim 169353358Sdim if (Query->isComplete()) 170353358Sdim Query->handleComplete(); 171341825Sdim 172341825Sdim return UnresolvedSymbols; 173341825Sdim } 174341825Sdim 175341825Sdim private: 176341825Sdim JITSymbol findSymbol(const std::string &Name) { 177341825Sdim // Search order: 178341825Sdim // 1. JIT'd symbols. 179341825Sdim // 2. Runtime overrides. 180341825Sdim // 3. External resolver (if present). 181341825Sdim 182344779Sdim if (Stack.CODLayer) { 183344779Sdim if (auto Sym = Stack.CODLayer->findSymbol(Name, true)) 184344779Sdim return Sym; 185344779Sdim else if (auto Err = Sym.takeError()) 186344779Sdim return Sym.takeError(); 187344779Sdim } else { 188344779Sdim if (auto Sym = Stack.CompileLayer.findSymbol(Name, true)) 189344779Sdim return Sym; 190344779Sdim else if (auto Err = Sym.takeError()) 191344779Sdim return Sym.takeError(); 192344779Sdim } 193341825Sdim 194341825Sdim if (auto Sym = Stack.CXXRuntimeOverrides.searchOverrides(Name)) 195341825Sdim return Sym; 196341825Sdim 197341825Sdim if (ExternalResolver) 198341825Sdim return JITSymbol(ExternalResolver(Name.c_str(), ExternalResolverCtx), 199341825Sdim JITSymbolFlags::Exported); 200341825Sdim 201341825Sdim return JITSymbol(nullptr); 202341825Sdim } 203341825Sdim 204341825Sdim OrcCBindingsStack &Stack; 205341825Sdim LLVMOrcSymbolResolverFn ExternalResolver; 206341825Sdim void *ExternalResolverCtx = nullptr; 207341825Sdim }; 208341825Sdim 209327952Sdimpublic: 210292915Sdim OrcCBindingsStack(TargetMachine &TM, 211292915Sdim IndirectStubsManagerBuilder IndirectStubsMgrBuilder) 212344779Sdim : CCMgr(createCompileCallbackManager(TM, ES)), DL(TM.createDataLayout()), 213344779Sdim IndirectStubsMgr(IndirectStubsMgrBuilder()), 214353358Sdim ObjectLayer( 215353358Sdim AcknowledgeORCv1Deprecation, ES, 216353358Sdim [this](orc::VModuleKey K) { 217353358Sdim auto ResolverI = Resolvers.find(K); 218353358Sdim assert(ResolverI != Resolvers.end() && 219353358Sdim "No resolver for module K"); 220353358Sdim auto Resolver = std::move(ResolverI->second); 221353358Sdim Resolvers.erase(ResolverI); 222353358Sdim return ObjLayerT::Resources{ 223353358Sdim std::make_shared<SectionMemoryManager>(), Resolver}; 224353358Sdim }, 225353358Sdim nullptr, 226353358Sdim [this](orc::VModuleKey K, const object::ObjectFile &Obj, 227353358Sdim const RuntimeDyld::LoadedObjectInfo &LoadedObjInfo) { 228353358Sdim this->notifyFinalized(K, Obj, LoadedObjInfo); 229353358Sdim }, 230353358Sdim [this](orc::VModuleKey K, const object::ObjectFile &Obj) { 231353358Sdim this->notifyFreed(K, Obj); 232353358Sdim }), 233353358Sdim CompileLayer(AcknowledgeORCv1Deprecation, ObjectLayer, 234353358Sdim orc::SimpleCompiler(TM)), 235344779Sdim CODLayer(createCODLayer(ES, CompileLayer, CCMgr.get(), 236344779Sdim std::move(IndirectStubsMgrBuilder), Resolvers)), 237309124Sdim CXXRuntimeOverrides( 238353358Sdim AcknowledgeORCv1Deprecation, 239309124Sdim [this](const std::string &S) { return mangle(S); }) {} 240292915Sdim 241344779Sdim Error shutdown() { 242292915Sdim // Run any destructors registered with __cxa_atexit. 243292915Sdim CXXRuntimeOverrides.runDestructors(); 244292915Sdim // Run any IR destructors. 245292915Sdim for (auto &DtorRunner : IRStaticDestructorRunners) 246321369Sdim if (auto Err = DtorRunner.runViaLayer(*this)) 247344779Sdim return Err; 248344779Sdim return Error::success(); 249292915Sdim } 250292915Sdim 251292915Sdim std::string mangle(StringRef Name) { 252292915Sdim std::string MangledName; 253292915Sdim { 254292915Sdim raw_string_ostream MangledNameStream(MangledName); 255292915Sdim Mangler::getNameWithPrefix(MangledNameStream, Name, DL); 256292915Sdim } 257292915Sdim return MangledName; 258292915Sdim } 259292915Sdim 260292915Sdim template <typename PtrTy> 261314564Sdim static PtrTy fromTargetAddress(JITTargetAddress Addr) { 262292915Sdim return reinterpret_cast<PtrTy>(static_cast<uintptr_t>(Addr)); 263292915Sdim } 264292915Sdim 265344779Sdim Expected<JITTargetAddress> 266344779Sdim createLazyCompileCallback(LLVMOrcLazyCompileCallbackFn Callback, 267292915Sdim void *CallbackCtx) { 268341825Sdim auto WrappedCallback = [=]() -> JITTargetAddress { 269341825Sdim return Callback(wrap(this), CallbackCtx); 270341825Sdim }; 271341825Sdim 272344779Sdim return CCMgr->getCompileCallback(std::move(WrappedCallback)); 273292915Sdim } 274292915Sdim 275344779Sdim Error createIndirectStub(StringRef StubName, JITTargetAddress Addr) { 276344779Sdim return IndirectStubsMgr->createStub(StubName, Addr, 277344779Sdim JITSymbolFlags::Exported); 278292915Sdim } 279292915Sdim 280344779Sdim Error setIndirectStubPointer(StringRef Name, JITTargetAddress Addr) { 281344779Sdim return IndirectStubsMgr->updatePointer(Name, Addr); 282292915Sdim } 283344779Sdim 284292915Sdim template <typename LayerT> 285344779Sdim Expected<orc::VModuleKey> 286344779Sdim addIRModule(LayerT &Layer, std::unique_ptr<Module> M, 287321369Sdim std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr, 288321369Sdim LLVMOrcSymbolResolverFn ExternalResolver, 289321369Sdim void *ExternalResolverCtx) { 290292915Sdim 291292915Sdim // Attach a data-layout if one isn't already present. 292292915Sdim if (M->getDataLayout().isDefault()) 293292915Sdim M->setDataLayout(DL); 294292915Sdim 295292915Sdim // Record the static constructors and destructors. We have to do this before 296292915Sdim // we hand over ownership of the module to the JIT. 297292915Sdim std::vector<std::string> CtorNames, DtorNames; 298292915Sdim for (auto Ctor : orc::getConstructors(*M)) 299292915Sdim CtorNames.push_back(mangle(Ctor.Func->getName())); 300292915Sdim for (auto Dtor : orc::getDestructors(*M)) 301292915Sdim DtorNames.push_back(mangle(Dtor.Func->getName())); 302292915Sdim 303292915Sdim // Add the module to the JIT. 304344779Sdim auto K = ES.allocateVModule(); 305344779Sdim Resolvers[K] = std::make_shared<CBindingsResolver>(*this, ExternalResolver, 306344779Sdim ExternalResolverCtx); 307344779Sdim if (auto Err = Layer.addModule(K, std::move(M))) 308344779Sdim return std::move(Err); 309292915Sdim 310344779Sdim KeyLayers[K] = detail::createGenericLayer(Layer); 311341825Sdim 312292915Sdim // Run the static constructors, and save the static destructor runner for 313292915Sdim // execution when the JIT is torn down. 314353358Sdim orc::LegacyCtorDtorRunner<OrcCBindingsStack> CtorRunner( 315353358Sdim AcknowledgeORCv1Deprecation, std::move(CtorNames), K); 316321369Sdim if (auto Err = CtorRunner.runViaLayer(*this)) 317344779Sdim return std::move(Err); 318292915Sdim 319360784Sdim IRStaticDestructorRunners.emplace_back(AcknowledgeORCv1Deprecation, 320360784Sdim std::move(DtorNames), K); 321292915Sdim 322344779Sdim return K; 323292915Sdim } 324292915Sdim 325344779Sdim Expected<orc::VModuleKey> 326344779Sdim addIRModuleEager(std::unique_ptr<Module> M, 327344779Sdim LLVMOrcSymbolResolverFn ExternalResolver, 328344779Sdim void *ExternalResolverCtx) { 329344779Sdim return addIRModule(CompileLayer, std::move(M), 330360784Sdim std::make_unique<SectionMemoryManager>(), 331292915Sdim std::move(ExternalResolver), ExternalResolverCtx); 332292915Sdim } 333292915Sdim 334344779Sdim Expected<orc::VModuleKey> 335344779Sdim addIRModuleLazy(std::unique_ptr<Module> M, 336344779Sdim LLVMOrcSymbolResolverFn ExternalResolver, 337344779Sdim void *ExternalResolverCtx) { 338344779Sdim if (!CODLayer) 339344779Sdim return make_error<StringError>("Can not add lazy module: No compile " 340344779Sdim "callback manager available", 341344779Sdim inconvertibleErrorCode()); 342344779Sdim 343344779Sdim return addIRModule(*CODLayer, std::move(M), 344360784Sdim std::make_unique<SectionMemoryManager>(), 345292915Sdim std::move(ExternalResolver), ExternalResolverCtx); 346292915Sdim } 347292915Sdim 348344779Sdim Error removeModule(orc::VModuleKey K) { 349341825Sdim // FIXME: Should error release the module key? 350341825Sdim if (auto Err = KeyLayers[K]->removeModule(K)) 351344779Sdim return Err; 352341825Sdim ES.releaseVModule(K); 353341825Sdim KeyLayers.erase(K); 354344779Sdim return Error::success(); 355292915Sdim } 356292915Sdim 357344779Sdim Expected<orc::VModuleKey> addObject(std::unique_ptr<MemoryBuffer> ObjBuffer, 358344779Sdim LLVMOrcSymbolResolverFn ExternalResolver, 359344779Sdim void *ExternalResolverCtx) { 360341825Sdim if (auto Obj = object::ObjectFile::createObjectFile( 361341825Sdim ObjBuffer->getMemBufferRef())) { 362327952Sdim 363344779Sdim auto K = ES.allocateVModule(); 364344779Sdim Resolvers[K] = std::make_shared<CBindingsResolver>( 365341825Sdim *this, ExternalResolver, ExternalResolverCtx); 366327952Sdim 367344779Sdim if (auto Err = ObjectLayer.addObject(K, std::move(ObjBuffer))) 368344779Sdim return std::move(Err); 369327952Sdim 370344779Sdim KeyLayers[K] = detail::createGenericLayer(ObjectLayer); 371327952Sdim 372344779Sdim return K; 373327952Sdim } else 374344779Sdim return Obj.takeError(); 375327952Sdim } 376327952Sdim 377321369Sdim JITSymbol findSymbol(const std::string &Name, 378321369Sdim bool ExportedSymbolsOnly) { 379292915Sdim if (auto Sym = IndirectStubsMgr->findStub(Name, ExportedSymbolsOnly)) 380292915Sdim return Sym; 381344779Sdim if (CODLayer) 382344779Sdim return CODLayer->findSymbol(mangle(Name), ExportedSymbolsOnly); 383344779Sdim return CompileLayer.findSymbol(mangle(Name), ExportedSymbolsOnly); 384292915Sdim } 385292915Sdim 386341825Sdim JITSymbol findSymbolIn(orc::VModuleKey K, const std::string &Name, 387314564Sdim bool ExportedSymbolsOnly) { 388341825Sdim assert(KeyLayers.count(K) && "looking up symbol in unknown module"); 389341825Sdim return KeyLayers[K]->findSymbolIn(K, mangle(Name), ExportedSymbolsOnly); 390292915Sdim } 391292915Sdim 392344779Sdim Expected<JITTargetAddress> findSymbolAddress(const std::string &Name, 393344779Sdim bool ExportedSymbolsOnly) { 394321369Sdim if (auto Sym = findSymbol(Name, ExportedSymbolsOnly)) { 395321369Sdim // Successful lookup, non-null symbol: 396344779Sdim if (auto AddrOrErr = Sym.getAddress()) 397344779Sdim return *AddrOrErr; 398344779Sdim else 399344779Sdim return AddrOrErr.takeError(); 400321369Sdim } else if (auto Err = Sym.takeError()) { 401321369Sdim // Lookup failure - report error. 402344779Sdim return std::move(Err); 403321369Sdim } 404344779Sdim 405344779Sdim // No symbol not found. Return 0. 406344779Sdim return 0; 407321369Sdim } 408321369Sdim 409344779Sdim Expected<JITTargetAddress> findSymbolAddressIn(orc::VModuleKey K, 410344779Sdim const std::string &Name, 411344779Sdim bool ExportedSymbolsOnly) { 412341825Sdim if (auto Sym = findSymbolIn(K, Name, ExportedSymbolsOnly)) { 413341825Sdim // Successful lookup, non-null symbol: 414344779Sdim if (auto AddrOrErr = Sym.getAddress()) 415344779Sdim return *AddrOrErr; 416344779Sdim else 417344779Sdim return AddrOrErr.takeError(); 418341825Sdim } else if (auto Err = Sym.takeError()) { 419341825Sdim // Lookup failure - report error. 420344779Sdim return std::move(Err); 421341825Sdim } 422344779Sdim 423344779Sdim // Symbol not found. Return 0. 424344779Sdim return 0; 425341825Sdim } 426341825Sdim 427309124Sdim const std::string &getErrorMessage() const { return ErrMsg; } 428309124Sdim 429341825Sdim void RegisterJITEventListener(JITEventListener *L) { 430341825Sdim if (!L) 431341825Sdim return; 432341825Sdim EventListeners.push_back(L); 433341825Sdim } 434341825Sdim 435341825Sdim void UnregisterJITEventListener(JITEventListener *L) { 436341825Sdim if (!L) 437341825Sdim return; 438341825Sdim 439341825Sdim auto I = find(reverse(EventListeners), L); 440341825Sdim if (I != EventListeners.rend()) { 441341825Sdim std::swap(*I, EventListeners.back()); 442341825Sdim EventListeners.pop_back(); 443292915Sdim } 444292915Sdim } 445292915Sdim 446341825Sdimprivate: 447344779Sdim using ResolverMap = 448344779Sdim std::map<orc::VModuleKey, std::shared_ptr<orc::SymbolResolver>>; 449341825Sdim 450344779Sdim static std::unique_ptr<CompileCallbackMgr> 451344779Sdim createCompileCallbackManager(TargetMachine &TM, orc::ExecutionSession &ES) { 452344779Sdim auto CCMgr = createLocalCompileCallbackManager(TM.getTargetTriple(), ES, 0); 453344779Sdim if (!CCMgr) { 454344779Sdim // FIXME: It would be good if we could report this somewhere, but we do 455344779Sdim // have an instance yet. 456344779Sdim logAllUnhandledErrors(CCMgr.takeError(), errs(), "ORC error: "); 457344779Sdim return nullptr; 458344779Sdim } 459344779Sdim return std::move(*CCMgr); 460309124Sdim } 461309124Sdim 462344779Sdim static std::unique_ptr<CODLayerT> 463344779Sdim createCODLayer(orc::ExecutionSession &ES, CompileLayerT &CompileLayer, 464344779Sdim CompileCallbackMgr *CCMgr, 465344779Sdim IndirectStubsManagerBuilder IndirectStubsMgrBuilder, 466344779Sdim ResolverMap &Resolvers) { 467344779Sdim // If there is no compile callback manager available we can not create a 468344779Sdim // compile on demand layer. 469344779Sdim if (!CCMgr) 470344779Sdim return nullptr; 471344779Sdim 472360784Sdim return std::make_unique<CODLayerT>( 473353358Sdim AcknowledgeORCv1Deprecation, ES, CompileLayer, 474344779Sdim [&Resolvers](orc::VModuleKey K) { 475344779Sdim auto ResolverI = Resolvers.find(K); 476344779Sdim assert(ResolverI != Resolvers.end() && "No resolver for module K"); 477344779Sdim return ResolverI->second; 478344779Sdim }, 479344779Sdim [&Resolvers](orc::VModuleKey K, 480344779Sdim std::shared_ptr<orc::SymbolResolver> Resolver) { 481344779Sdim assert(!Resolvers.count(K) && "Resolver already present"); 482344779Sdim Resolvers[K] = std::move(Resolver); 483344779Sdim }, 484344779Sdim [](Function &F) { return std::set<Function *>({&F}); }, *CCMgr, 485344779Sdim std::move(IndirectStubsMgrBuilder), false); 486344779Sdim } 487344779Sdim 488341825Sdim void reportError(Error Err) { 489341825Sdim // FIXME: Report errors on the execution session. 490341825Sdim logAllUnhandledErrors(std::move(Err), errs(), "ORC error: "); 491341825Sdim }; 492341825Sdim 493341825Sdim void notifyFinalized(orc::VModuleKey K, 494341825Sdim const object::ObjectFile &Obj, 495341825Sdim const RuntimeDyld::LoadedObjectInfo &LoadedObjInfo) { 496344779Sdim uint64_t Key = static_cast<uint64_t>( 497344779Sdim reinterpret_cast<uintptr_t>(Obj.getData().data())); 498341825Sdim for (auto &Listener : EventListeners) 499344779Sdim Listener->notifyObjectLoaded(Key, Obj, LoadedObjInfo); 500341825Sdim } 501341825Sdim 502341825Sdim void notifyFreed(orc::VModuleKey K, const object::ObjectFile &Obj) { 503344779Sdim uint64_t Key = static_cast<uint64_t>( 504344779Sdim reinterpret_cast<uintptr_t>(Obj.getData().data())); 505341825Sdim for (auto &Listener : EventListeners) 506344779Sdim Listener->notifyFreeingObject(Key); 507341825Sdim } 508341825Sdim 509341825Sdim orc::ExecutionSession ES; 510341825Sdim std::unique_ptr<CompileCallbackMgr> CCMgr; 511341825Sdim 512341825Sdim std::vector<JITEventListener *> EventListeners; 513341825Sdim 514292915Sdim DataLayout DL; 515292915Sdim SectionMemoryManager CCMgrMemMgr; 516292915Sdim 517309124Sdim std::unique_ptr<orc::IndirectStubsManager> IndirectStubsMgr; 518309124Sdim 519292915Sdim ObjLayerT ObjectLayer; 520292915Sdim CompileLayerT CompileLayer; 521344779Sdim std::unique_ptr<CODLayerT> CODLayer; 522292915Sdim 523341825Sdim std::map<orc::VModuleKey, std::unique_ptr<detail::GenericLayer>> KeyLayers; 524292915Sdim 525344779Sdim orc::LegacyLocalCXXRuntimeOverrides CXXRuntimeOverrides; 526344779Sdim std::vector<orc::LegacyCtorDtorRunner<OrcCBindingsStack>> IRStaticDestructorRunners; 527309124Sdim std::string ErrMsg; 528341825Sdim 529344779Sdim ResolverMap Resolvers; 530292915Sdim}; 531292915Sdim 532292915Sdim} // end namespace llvm 533292915Sdim 534292915Sdim#endif // LLVM_LIB_EXECUTIONENGINE_ORC_ORCCBINDINGSSTACK_H 535