1321369Sdim//===- OrcMCJITReplacement.h - Orc based MCJIT replacement ------*- C++ -*-===// 2283625Sdim// 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 6283625Sdim// 7283625Sdim//===----------------------------------------------------------------------===// 8283625Sdim// 9283625Sdim// Orc based MCJIT replacement. 10283625Sdim// 11283625Sdim//===----------------------------------------------------------------------===// 12283625Sdim 13283625Sdim#ifndef LLVM_LIB_EXECUTIONENGINE_ORC_ORCMCJITREPLACEMENT_H 14283625Sdim#define LLVM_LIB_EXECUTIONENGINE_ORC_ORCMCJITREPLACEMENT_H 15283625Sdim 16314564Sdim#include "llvm/ADT/ArrayRef.h" 17314564Sdim#include "llvm/ADT/STLExtras.h" 18314564Sdim#include "llvm/ADT/StringRef.h" 19283625Sdim#include "llvm/ExecutionEngine/ExecutionEngine.h" 20314564Sdim#include "llvm/ExecutionEngine/GenericValue.h" 21314564Sdim#include "llvm/ExecutionEngine/JITSymbol.h" 22283625Sdim#include "llvm/ExecutionEngine/Orc/CompileUtils.h" 23341825Sdim#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h" 24283625Sdim#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h" 25283625Sdim#include "llvm/ExecutionEngine/Orc/LazyEmittingLayer.h" 26321369Sdim#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h" 27321369Sdim#include "llvm/ExecutionEngine/RTDyldMemoryManager.h" 28321369Sdim#include "llvm/ExecutionEngine/RuntimeDyld.h" 29321369Sdim#include "llvm/IR/DataLayout.h" 30314564Sdim#include "llvm/IR/Function.h" 31314564Sdim#include "llvm/IR/Mangler.h" 32321369Sdim#include "llvm/IR/Module.h" 33283625Sdim#include "llvm/Object/Archive.h" 34314564Sdim#include "llvm/Object/Binary.h" 35314564Sdim#include "llvm/Object/ObjectFile.h" 36314564Sdim#include "llvm/Support/Error.h" 37314564Sdim#include "llvm/Support/ErrorHandling.h" 38314564Sdim#include "llvm/Support/raw_ostream.h" 39314564Sdim#include "llvm/Target/TargetMachine.h" 40321369Sdim#include <algorithm> 41314564Sdim#include <cassert> 42314564Sdim#include <cstddef> 43314564Sdim#include <cstdint> 44314564Sdim#include <map> 45314564Sdim#include <memory> 46314564Sdim#include <set> 47314564Sdim#include <string> 48314564Sdim#include <vector> 49283625Sdim 50283625Sdimnamespace llvm { 51321369Sdim 52321369Sdimclass ObjectCache; 53321369Sdim 54283625Sdimnamespace orc { 55283625Sdim 56283625Sdimclass OrcMCJITReplacement : public ExecutionEngine { 57341825Sdim 58283625Sdim // OrcMCJITReplacement needs to do a little extra book-keeping to ensure that 59283625Sdim // Orc's automatic finalization doesn't kick in earlier than MCJIT clients are 60283625Sdim // expecting - see finalizeMemory. 61283625Sdim class MCJITReplacementMemMgr : public MCJITMemoryManager { 62283625Sdim public: 63283625Sdim MCJITReplacementMemMgr(OrcMCJITReplacement &M, 64283625Sdim std::shared_ptr<MCJITMemoryManager> ClientMM) 65283625Sdim : M(M), ClientMM(std::move(ClientMM)) {} 66283625Sdim 67283625Sdim uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment, 68283625Sdim unsigned SectionID, 69283625Sdim StringRef SectionName) override { 70283625Sdim uint8_t *Addr = 71283625Sdim ClientMM->allocateCodeSection(Size, Alignment, SectionID, 72283625Sdim SectionName); 73283625Sdim M.SectionsAllocatedSinceLastLoad.insert(Addr); 74283625Sdim return Addr; 75283625Sdim } 76283625Sdim 77283625Sdim uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment, 78283625Sdim unsigned SectionID, StringRef SectionName, 79283625Sdim bool IsReadOnly) override { 80283625Sdim uint8_t *Addr = ClientMM->allocateDataSection(Size, Alignment, SectionID, 81283625Sdim SectionName, IsReadOnly); 82283625Sdim M.SectionsAllocatedSinceLastLoad.insert(Addr); 83283625Sdim return Addr; 84283625Sdim } 85283625Sdim 86296417Sdim void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign, 87296417Sdim uintptr_t RODataSize, uint32_t RODataAlign, 88296417Sdim uintptr_t RWDataSize, 89296417Sdim uint32_t RWDataAlign) override { 90296417Sdim return ClientMM->reserveAllocationSpace(CodeSize, CodeAlign, 91296417Sdim RODataSize, RODataAlign, 92296417Sdim RWDataSize, RWDataAlign); 93283625Sdim } 94283625Sdim 95283625Sdim bool needsToReserveAllocationSpace() override { 96283625Sdim return ClientMM->needsToReserveAllocationSpace(); 97283625Sdim } 98283625Sdim 99283625Sdim void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, 100283625Sdim size_t Size) override { 101283625Sdim return ClientMM->registerEHFrames(Addr, LoadAddr, Size); 102283625Sdim } 103283625Sdim 104321369Sdim void deregisterEHFrames() override { 105321369Sdim return ClientMM->deregisterEHFrames(); 106283625Sdim } 107283625Sdim 108296417Sdim void notifyObjectLoaded(RuntimeDyld &RTDyld, 109296417Sdim const object::ObjectFile &O) override { 110296417Sdim return ClientMM->notifyObjectLoaded(RTDyld, O); 111296417Sdim } 112296417Sdim 113283625Sdim void notifyObjectLoaded(ExecutionEngine *EE, 114283625Sdim const object::ObjectFile &O) override { 115283625Sdim return ClientMM->notifyObjectLoaded(EE, O); 116283625Sdim } 117283625Sdim 118283625Sdim bool finalizeMemory(std::string *ErrMsg = nullptr) override { 119283625Sdim // Each set of objects loaded will be finalized exactly once, but since 120283625Sdim // symbol lookup during relocation may recursively trigger the 121283625Sdim // loading/relocation of other modules, and since we're forwarding all 122283625Sdim // finalizeMemory calls to a single underlying memory manager, we need to 123283625Sdim // defer forwarding the call on until all necessary objects have been 124283625Sdim // loaded. Otherwise, during the relocation of a leaf object, we will end 125283625Sdim // up finalizing memory, causing a crash further up the stack when we 126283625Sdim // attempt to apply relocations to finalized memory. 127283625Sdim // To avoid finalizing too early, look at how many objects have been 128283625Sdim // loaded but not yet finalized. This is a bit of a hack that relies on 129283625Sdim // the fact that we're lazily emitting object files: The only way you can 130283625Sdim // get more than one set of objects loaded but not yet finalized is if 131283625Sdim // they were loaded during relocation of another set. 132283625Sdim if (M.UnfinalizedSections.size() == 1) 133283625Sdim return ClientMM->finalizeMemory(ErrMsg); 134283625Sdim return false; 135283625Sdim } 136283625Sdim 137283625Sdim private: 138283625Sdim OrcMCJITReplacement &M; 139283625Sdim std::shared_ptr<MCJITMemoryManager> ClientMM; 140283625Sdim }; 141283625Sdim 142341825Sdim class LinkingORCResolver : public orc::SymbolResolver { 143283625Sdim public: 144341825Sdim LinkingORCResolver(OrcMCJITReplacement &M) : M(M) {} 145283625Sdim 146344779Sdim SymbolNameSet getResponsibilitySet(const SymbolNameSet &Symbols) override { 147344779Sdim SymbolNameSet Result; 148341825Sdim 149341825Sdim for (auto &S : Symbols) { 150341825Sdim if (auto Sym = M.findMangledSymbol(*S)) { 151344779Sdim if (!Sym.getFlags().isStrong()) 152344779Sdim Result.insert(S); 153341825Sdim } else if (auto Err = Sym.takeError()) { 154341825Sdim M.reportError(std::move(Err)); 155344779Sdim return SymbolNameSet(); 156341825Sdim } else { 157341825Sdim if (auto Sym2 = M.ClientResolver->findSymbolInLogicalDylib(*S)) { 158344779Sdim if (!Sym2.getFlags().isStrong()) 159344779Sdim Result.insert(S); 160341825Sdim } else if (auto Err = Sym2.takeError()) { 161341825Sdim M.reportError(std::move(Err)); 162344779Sdim return SymbolNameSet(); 163344779Sdim } else 164344779Sdim Result.insert(S); 165341825Sdim } 166341825Sdim } 167341825Sdim 168344779Sdim return Result; 169283625Sdim } 170283625Sdim 171341825Sdim SymbolNameSet lookup(std::shared_ptr<AsynchronousSymbolQuery> Query, 172341825Sdim SymbolNameSet Symbols) override { 173341825Sdim SymbolNameSet UnresolvedSymbols; 174341825Sdim bool NewSymbolsResolved = false; 175341825Sdim 176341825Sdim for (auto &S : Symbols) { 177341825Sdim if (auto Sym = M.findMangledSymbol(*S)) { 178341825Sdim if (auto Addr = Sym.getAddress()) { 179353358Sdim Query->notifySymbolMetRequiredState( 180353358Sdim S, JITEvaluatedSymbol(*Addr, Sym.getFlags())); 181341825Sdim NewSymbolsResolved = true; 182341825Sdim } else { 183341825Sdim M.ES.legacyFailQuery(*Query, Addr.takeError()); 184341825Sdim return SymbolNameSet(); 185341825Sdim } 186341825Sdim } else if (auto Err = Sym.takeError()) { 187341825Sdim M.ES.legacyFailQuery(*Query, std::move(Err)); 188341825Sdim return SymbolNameSet(); 189341825Sdim } else { 190341825Sdim if (auto Sym2 = M.ClientResolver->findSymbol(*S)) { 191341825Sdim if (auto Addr = Sym2.getAddress()) { 192353358Sdim Query->notifySymbolMetRequiredState( 193353358Sdim S, JITEvaluatedSymbol(*Addr, Sym2.getFlags())); 194341825Sdim NewSymbolsResolved = true; 195341825Sdim } else { 196341825Sdim M.ES.legacyFailQuery(*Query, Addr.takeError()); 197341825Sdim return SymbolNameSet(); 198341825Sdim } 199341825Sdim } else if (auto Err = Sym2.takeError()) { 200341825Sdim M.ES.legacyFailQuery(*Query, std::move(Err)); 201341825Sdim return SymbolNameSet(); 202341825Sdim } else 203341825Sdim UnresolvedSymbols.insert(S); 204341825Sdim } 205341825Sdim } 206341825Sdim 207353358Sdim if (NewSymbolsResolved && Query->isComplete()) 208353358Sdim Query->handleComplete(); 209341825Sdim 210341825Sdim return UnresolvedSymbols; 211283625Sdim } 212283625Sdim 213283625Sdim private: 214283625Sdim OrcMCJITReplacement &M; 215283625Sdim }; 216283625Sdim 217283625Sdimprivate: 218283625Sdim static ExecutionEngine * 219283625Sdim createOrcMCJITReplacement(std::string *ErrorMsg, 220283625Sdim std::shared_ptr<MCJITMemoryManager> MemMgr, 221341825Sdim std::shared_ptr<LegacyJITSymbolResolver> Resolver, 222283625Sdim std::unique_ptr<TargetMachine> TM) { 223283625Sdim return new OrcMCJITReplacement(std::move(MemMgr), std::move(Resolver), 224283625Sdim std::move(TM)); 225283625Sdim } 226283625Sdim 227341825Sdim void reportError(Error Err) { 228341825Sdim logAllUnhandledErrors(std::move(Err), errs(), "MCJIT error: "); 229341825Sdim } 230341825Sdim 231283625Sdimpublic: 232341825Sdim OrcMCJITReplacement(std::shared_ptr<MCJITMemoryManager> MemMgr, 233341825Sdim std::shared_ptr<LegacyJITSymbolResolver> ClientResolver, 234341825Sdim std::unique_ptr<TargetMachine> TM) 235353358Sdim : ExecutionEngine(TM->createDataLayout()), TM(std::move(TM)), 236341825Sdim MemMgr( 237341825Sdim std::make_shared<MCJITReplacementMemMgr>(*this, std::move(MemMgr))), 238341825Sdim Resolver(std::make_shared<LinkingORCResolver>(*this)), 239296417Sdim ClientResolver(std::move(ClientResolver)), NotifyObjectLoaded(*this), 240296417Sdim NotifyFinalized(*this), 241341825Sdim ObjectLayer( 242353358Sdim AcknowledgeORCv1Deprecation, ES, 243341825Sdim [this](VModuleKey K) { 244341825Sdim return ObjectLayerT::Resources{this->MemMgr, this->Resolver}; 245341825Sdim }, 246341825Sdim NotifyObjectLoaded, NotifyFinalized), 247353358Sdim CompileLayer(AcknowledgeORCv1Deprecation, ObjectLayer, 248353358Sdim SimpleCompiler(*this->TM), 249341825Sdim [this](VModuleKey K, std::unique_ptr<Module> M) { 250341825Sdim Modules.push_back(std::move(M)); 251341825Sdim }), 252353358Sdim LazyEmitLayer(AcknowledgeORCv1Deprecation, CompileLayer) {} 253283625Sdim 254321369Sdim static void Register() { 255321369Sdim OrcMCJITReplacementCtor = createOrcMCJITReplacement; 256321369Sdim } 257321369Sdim 258283625Sdim void addModule(std::unique_ptr<Module> M) override { 259283625Sdim // If this module doesn't have a DataLayout attached then attach the 260283625Sdim // default. 261296417Sdim if (M->getDataLayout().isDefault()) { 262296417Sdim M->setDataLayout(getDataLayout()); 263296417Sdim } else { 264296417Sdim assert(M->getDataLayout() == getDataLayout() && "DataLayout Mismatch"); 265296417Sdim } 266341825Sdim 267341825Sdim // Rename, bump linkage and record static constructors and destructors. 268341825Sdim // We have to do this before we hand over ownership of the module to the 269341825Sdim // JIT. 270341825Sdim std::vector<std::string> CtorNames, DtorNames; 271341825Sdim { 272341825Sdim unsigned CtorId = 0, DtorId = 0; 273341825Sdim for (auto Ctor : orc::getConstructors(*M)) { 274344779Sdim std::string NewCtorName = ("__ORCstatic_ctor." + Twine(CtorId++)).str(); 275341825Sdim Ctor.Func->setName(NewCtorName); 276341825Sdim Ctor.Func->setLinkage(GlobalValue::ExternalLinkage); 277341825Sdim Ctor.Func->setVisibility(GlobalValue::HiddenVisibility); 278341825Sdim CtorNames.push_back(mangle(NewCtorName)); 279341825Sdim } 280341825Sdim for (auto Dtor : orc::getDestructors(*M)) { 281344779Sdim std::string NewDtorName = ("__ORCstatic_dtor." + Twine(DtorId++)).str(); 282341825Sdim dbgs() << "Found dtor: " << NewDtorName << "\n"; 283341825Sdim Dtor.Func->setName(NewDtorName); 284341825Sdim Dtor.Func->setLinkage(GlobalValue::ExternalLinkage); 285341825Sdim Dtor.Func->setVisibility(GlobalValue::HiddenVisibility); 286341825Sdim DtorNames.push_back(mangle(NewDtorName)); 287341825Sdim } 288341825Sdim } 289341825Sdim 290341825Sdim auto K = ES.allocateVModule(); 291341825Sdim 292341825Sdim UnexecutedConstructors[K] = std::move(CtorNames); 293341825Sdim UnexecutedDestructors[K] = std::move(DtorNames); 294341825Sdim 295341825Sdim cantFail(LazyEmitLayer.addModule(K, std::move(M))); 296283625Sdim } 297283625Sdim 298283625Sdim void addObjectFile(std::unique_ptr<object::ObjectFile> O) override { 299341825Sdim cantFail(ObjectLayer.addObject( 300341825Sdim ES.allocateVModule(), MemoryBuffer::getMemBufferCopy(O->getData()))); 301283625Sdim } 302283625Sdim 303283625Sdim void addObjectFile(object::OwningBinary<object::ObjectFile> O) override { 304341825Sdim std::unique_ptr<object::ObjectFile> Obj; 305341825Sdim std::unique_ptr<MemoryBuffer> ObjBuffer; 306341825Sdim std::tie(Obj, ObjBuffer) = O.takeBinary(); 307341825Sdim cantFail(ObjectLayer.addObject(ES.allocateVModule(), std::move(ObjBuffer))); 308283625Sdim } 309283625Sdim 310283625Sdim void addArchive(object::OwningBinary<object::Archive> A) override { 311283625Sdim Archives.push_back(std::move(A)); 312283625Sdim } 313341825Sdim 314321369Sdim bool removeModule(Module *M) override { 315341825Sdim auto I = Modules.begin(); 316341825Sdim for (auto E = Modules.end(); I != E; ++I) 317341825Sdim if (I->get() == M) 318341825Sdim break; 319341825Sdim if (I == Modules.end()) 320341825Sdim return false; 321341825Sdim Modules.erase(I); 322341825Sdim return true; 323321369Sdim } 324283625Sdim 325283625Sdim uint64_t getSymbolAddress(StringRef Name) { 326321369Sdim return cantFail(findSymbol(Name).getAddress()); 327283625Sdim } 328283625Sdim 329314564Sdim JITSymbol findSymbol(StringRef Name) { 330341825Sdim return findMangledSymbol(mangle(Name)); 331283625Sdim } 332283625Sdim 333283625Sdim void finalizeObject() override { 334283625Sdim // This is deprecated - Aim to remove in ExecutionEngine. 335283625Sdim // REMOVE IF POSSIBLE - Doesn't make sense for New JIT. 336283625Sdim } 337283625Sdim 338283625Sdim void mapSectionAddress(const void *LocalAddress, 339283625Sdim uint64_t TargetAddress) override { 340283625Sdim for (auto &P : UnfinalizedSections) 341283625Sdim if (P.second.count(LocalAddress)) 342283625Sdim ObjectLayer.mapSectionAddress(P.first, LocalAddress, TargetAddress); 343283625Sdim } 344283625Sdim 345283625Sdim uint64_t getGlobalValueAddress(const std::string &Name) override { 346283625Sdim return getSymbolAddress(Name); 347283625Sdim } 348283625Sdim 349283625Sdim uint64_t getFunctionAddress(const std::string &Name) override { 350283625Sdim return getSymbolAddress(Name); 351283625Sdim } 352283625Sdim 353283625Sdim void *getPointerToFunction(Function *F) override { 354283625Sdim uint64_t FAddr = getSymbolAddress(F->getName()); 355283625Sdim return reinterpret_cast<void *>(static_cast<uintptr_t>(FAddr)); 356283625Sdim } 357283625Sdim 358283625Sdim void *getPointerToNamedFunction(StringRef Name, 359283625Sdim bool AbortOnFailure = true) override { 360283625Sdim uint64_t Addr = getSymbolAddress(Name); 361283625Sdim if (!Addr && AbortOnFailure) 362283625Sdim llvm_unreachable("Missing symbol!"); 363283625Sdim return reinterpret_cast<void *>(static_cast<uintptr_t>(Addr)); 364283625Sdim } 365283625Sdim 366283625Sdim GenericValue runFunction(Function *F, 367284734Sdim ArrayRef<GenericValue> ArgValues) override; 368283625Sdim 369283625Sdim void setObjectCache(ObjectCache *NewCache) override { 370321369Sdim CompileLayer.getCompiler().setObjectCache(NewCache); 371283625Sdim } 372283625Sdim 373296417Sdim void setProcessAllSections(bool ProcessAllSections) override { 374296417Sdim ObjectLayer.setProcessAllSections(ProcessAllSections); 375296417Sdim } 376296417Sdim 377321369Sdim void runStaticConstructorsDestructors(bool isDtors) override; 378321369Sdim 379283625Sdimprivate: 380314564Sdim JITSymbol findMangledSymbol(StringRef Name) { 381283625Sdim if (auto Sym = LazyEmitLayer.findSymbol(Name, false)) 382314564Sdim return Sym; 383283625Sdim if (auto Sym = ClientResolver->findSymbol(Name)) 384309124Sdim return Sym; 385283625Sdim if (auto Sym = scanArchives(Name)) 386314564Sdim return Sym; 387283625Sdim 388283625Sdim return nullptr; 389283625Sdim } 390283625Sdim 391283625Sdim JITSymbol scanArchives(StringRef Name) { 392283625Sdim for (object::OwningBinary<object::Archive> &OB : Archives) { 393283625Sdim object::Archive *A = OB.getBinary(); 394283625Sdim // Look for our symbols in each Archive 395309124Sdim auto OptionalChildOrErr = A->findSym(Name); 396309124Sdim if (!OptionalChildOrErr) 397309124Sdim report_fatal_error(OptionalChildOrErr.takeError()); 398309124Sdim auto &OptionalChild = *OptionalChildOrErr; 399309124Sdim if (OptionalChild) { 400283625Sdim // FIXME: Support nested archives? 401309124Sdim Expected<std::unique_ptr<object::Binary>> ChildBinOrErr = 402309124Sdim OptionalChild->getAsBinary(); 403309124Sdim if (!ChildBinOrErr) { 404309124Sdim // TODO: Actually report errors helpfully. 405309124Sdim consumeError(ChildBinOrErr.takeError()); 406283625Sdim continue; 407309124Sdim } 408283625Sdim std::unique_ptr<object::Binary> &ChildBin = ChildBinOrErr.get(); 409283625Sdim if (ChildBin->isObject()) { 410341825Sdim cantFail(ObjectLayer.addObject( 411341825Sdim ES.allocateVModule(), 412341825Sdim MemoryBuffer::getMemBufferCopy(ChildBin->getData()))); 413283625Sdim if (auto Sym = ObjectLayer.findSymbol(Name, true)) 414283625Sdim return Sym; 415283625Sdim } 416283625Sdim } 417283625Sdim } 418283625Sdim return nullptr; 419283625Sdim } 420283625Sdim 421283625Sdim class NotifyObjectLoadedT { 422283625Sdim public: 423321369Sdim using LoadedObjInfoListT = 424321369Sdim std::vector<std::unique_ptr<RuntimeDyld::LoadedObjectInfo>>; 425283625Sdim 426283625Sdim NotifyObjectLoadedT(OrcMCJITReplacement &M) : M(M) {} 427283625Sdim 428341825Sdim void operator()(VModuleKey K, const object::ObjectFile &Obj, 429327952Sdim const RuntimeDyld::LoadedObjectInfo &Info) const { 430341825Sdim M.UnfinalizedSections[K] = std::move(M.SectionsAllocatedSinceLastLoad); 431283625Sdim M.SectionsAllocatedSinceLastLoad = SectionAddrSet(); 432341825Sdim M.MemMgr->notifyObjectLoaded(&M, Obj); 433296417Sdim } 434283625Sdim private: 435283625Sdim OrcMCJITReplacement &M; 436283625Sdim }; 437283625Sdim 438283625Sdim class NotifyFinalizedT { 439283625Sdim public: 440283625Sdim NotifyFinalizedT(OrcMCJITReplacement &M) : M(M) {} 441314564Sdim 442341825Sdim void operator()(VModuleKey K, const object::ObjectFile &Obj, 443341825Sdim const RuntimeDyld::LoadedObjectInfo &Info) { 444341825Sdim M.UnfinalizedSections.erase(K); 445283625Sdim } 446283625Sdim 447283625Sdim private: 448283625Sdim OrcMCJITReplacement &M; 449283625Sdim }; 450283625Sdim 451341825Sdim std::string mangle(StringRef Name) { 452283625Sdim std::string MangledName; 453283625Sdim { 454283625Sdim raw_string_ostream MangledNameStream(MangledName); 455296417Sdim Mang.getNameWithPrefix(MangledNameStream, Name, getDataLayout()); 456283625Sdim } 457283625Sdim return MangledName; 458283625Sdim } 459283625Sdim 460344779Sdim using ObjectLayerT = LegacyRTDyldObjectLinkingLayer; 461344779Sdim using CompileLayerT = LegacyIRCompileLayer<ObjectLayerT, orc::SimpleCompiler>; 462321369Sdim using LazyEmitLayerT = LazyEmittingLayer<CompileLayerT>; 463283625Sdim 464341825Sdim ExecutionSession ES; 465341825Sdim 466283625Sdim std::unique_ptr<TargetMachine> TM; 467321369Sdim std::shared_ptr<MCJITReplacementMemMgr> MemMgr; 468341825Sdim std::shared_ptr<LinkingORCResolver> Resolver; 469341825Sdim std::shared_ptr<LegacyJITSymbolResolver> ClientResolver; 470283625Sdim Mangler Mang; 471283625Sdim 472327952Sdim // IMPORTANT: ShouldDelete *must* come before LocalModules: The shared_ptr 473327952Sdim // delete blocks in LocalModules refer to the ShouldDelete map, so 474327952Sdim // LocalModules needs to be destructed before ShouldDelete. 475327952Sdim std::map<Module*, bool> ShouldDelete; 476327952Sdim 477283625Sdim NotifyObjectLoadedT NotifyObjectLoaded; 478283625Sdim NotifyFinalizedT NotifyFinalized; 479283625Sdim 480283625Sdim ObjectLayerT ObjectLayer; 481283625Sdim CompileLayerT CompileLayer; 482283625Sdim LazyEmitLayerT LazyEmitLayer; 483283625Sdim 484341825Sdim std::map<VModuleKey, std::vector<std::string>> UnexecutedConstructors; 485341825Sdim std::map<VModuleKey, std::vector<std::string>> UnexecutedDestructors; 486341825Sdim 487283625Sdim // We need to store ObjLayerT::ObjSetHandles for each of the object sets 488283625Sdim // that have been emitted but not yet finalized so that we can forward the 489283625Sdim // mapSectionAddress calls appropriately. 490321369Sdim using SectionAddrSet = std::set<const void *>; 491283625Sdim SectionAddrSet SectionsAllocatedSinceLastLoad; 492341825Sdim std::map<VModuleKey, SectionAddrSet> UnfinalizedSections; 493283625Sdim 494283625Sdim std::vector<object::OwningBinary<object::Archive>> Archives; 495283625Sdim}; 496283625Sdim 497314564Sdim} // end namespace orc 498321369Sdim 499314564Sdim} // end namespace llvm 500283625Sdim 501283625Sdim#endif // LLVM_LIB_EXECUTIONENGINE_ORC_MCJITREPLACEMENT_H 502