diff options
Diffstat (limited to 'include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h')
| -rw-r--r-- | include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h | 784 |
1 files changed, 784 insertions, 0 deletions
diff --git a/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h b/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h new file mode 100644 index 0000000..d7640b8 --- /dev/null +++ b/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h @@ -0,0 +1,784 @@ +//===---- OrcRemoteTargetClient.h - Orc Remote-target Client ----*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the OrcRemoteTargetClient class and helpers. This class +// can be used to communicate over an RPCChannel with an OrcRemoteTargetServer +// instance to support remote-JITing. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETCLIENT_H +#define LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETCLIENT_H + +#include "IndirectionUtils.h" +#include "OrcRemoteTargetRPCAPI.h" +#include <system_error> + +#define DEBUG_TYPE "orc-remote" + +namespace llvm { +namespace orc { +namespace remote { + +/// This class provides utilities (including memory manager, indirect stubs +/// manager, and compile callback manager types) that support remote JITing +/// in ORC. +/// +/// Each of the utility classes talks to a JIT server (an instance of the +/// OrcRemoteTargetServer class) via an RPC system (see RPCUtils.h) to carry out +/// its actions. +template <typename ChannelT> +class OrcRemoteTargetClient : public OrcRemoteTargetRPCAPI { +public: + /// Remote memory manager. + class RCMemoryManager : public RuntimeDyld::MemoryManager { + public: + RCMemoryManager(OrcRemoteTargetClient &Client, ResourceIdMgr::ResourceId Id) + : Client(Client), Id(Id) { + DEBUG(dbgs() << "Created remote allocator " << Id << "\n"); + } + + RCMemoryManager(RCMemoryManager &&Other) + : Client(std::move(Other.Client)), Id(std::move(Other.Id)), + Unmapped(std::move(Other.Unmapped)), + Unfinalized(std::move(Other.Unfinalized)) {} + + RCMemoryManager operator=(RCMemoryManager &&Other) { + Client = std::move(Other.Client); + Id = std::move(Other.Id); + Unmapped = std::move(Other.Unmapped); + Unfinalized = std::move(Other.Unfinalized); + return *this; + } + + ~RCMemoryManager() { + Client.destroyRemoteAllocator(Id); + DEBUG(dbgs() << "Destroyed remote allocator " << Id << "\n"); + } + + uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment, + unsigned SectionID, + StringRef SectionName) override { + Unmapped.back().CodeAllocs.emplace_back(Size, Alignment); + uint8_t *Alloc = reinterpret_cast<uint8_t *>( + Unmapped.back().CodeAllocs.back().getLocalAddress()); + DEBUG(dbgs() << "Allocator " << Id << " allocated code for " + << SectionName << ": " << Alloc << " (" << Size + << " bytes, alignment " << Alignment << ")\n"); + return Alloc; + } + + uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment, + unsigned SectionID, StringRef SectionName, + bool IsReadOnly) override { + if (IsReadOnly) { + Unmapped.back().RODataAllocs.emplace_back(Size, Alignment); + uint8_t *Alloc = reinterpret_cast<uint8_t *>( + Unmapped.back().RODataAllocs.back().getLocalAddress()); + DEBUG(dbgs() << "Allocator " << Id << " allocated ro-data for " + << SectionName << ": " << Alloc << " (" << Size + << " bytes, alignment " << Alignment << ")\n"); + return Alloc; + } // else... + + Unmapped.back().RWDataAllocs.emplace_back(Size, Alignment); + uint8_t *Alloc = reinterpret_cast<uint8_t *>( + Unmapped.back().RWDataAllocs.back().getLocalAddress()); + DEBUG(dbgs() << "Allocator " << Id << " allocated rw-data for " + << SectionName << ": " << Alloc << " (" << Size + << " bytes, alignment " << Alignment << ")\n"); + return Alloc; + } + + void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign, + uintptr_t RODataSize, uint32_t RODataAlign, + uintptr_t RWDataSize, + uint32_t RWDataAlign) override { + Unmapped.push_back(ObjectAllocs()); + + DEBUG(dbgs() << "Allocator " << Id << " reserved:\n"); + + if (CodeSize != 0) { + std::error_code EC = Client.reserveMem(Unmapped.back().RemoteCodeAddr, + Id, CodeSize, CodeAlign); + // FIXME; Add error to poll. + assert(!EC && "Failed reserving remote memory."); + (void)EC; + DEBUG(dbgs() << " code: " + << format("0x%016x", Unmapped.back().RemoteCodeAddr) + << " (" << CodeSize << " bytes, alignment " << CodeAlign + << ")\n"); + } + + if (RODataSize != 0) { + std::error_code EC = Client.reserveMem(Unmapped.back().RemoteRODataAddr, + Id, RODataSize, RODataAlign); + // FIXME; Add error to poll. + assert(!EC && "Failed reserving remote memory."); + (void)EC; + DEBUG(dbgs() << " ro-data: " + << format("0x%016x", Unmapped.back().RemoteRODataAddr) + << " (" << RODataSize << " bytes, alignment " + << RODataAlign << ")\n"); + } + + if (RWDataSize != 0) { + std::error_code EC = Client.reserveMem(Unmapped.back().RemoteRWDataAddr, + Id, RWDataSize, RWDataAlign); + // FIXME; Add error to poll. + assert(!EC && "Failed reserving remote memory."); + (void)EC; + DEBUG(dbgs() << " rw-data: " + << format("0x%016x", Unmapped.back().RemoteRWDataAddr) + << " (" << RWDataSize << " bytes, alignment " + << RWDataAlign << ")\n"); + } + } + + bool needsToReserveAllocationSpace() override { return true; } + + void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, + size_t Size) override {} + + void deregisterEHFrames(uint8_t *addr, uint64_t LoadAddr, + size_t Size) override {} + + void notifyObjectLoaded(RuntimeDyld &Dyld, + const object::ObjectFile &Obj) override { + DEBUG(dbgs() << "Allocator " << Id << " applied mappings:\n"); + for (auto &ObjAllocs : Unmapped) { + { + TargetAddress NextCodeAddr = ObjAllocs.RemoteCodeAddr; + for (auto &Alloc : ObjAllocs.CodeAllocs) { + NextCodeAddr = RoundUpToAlignment(NextCodeAddr, Alloc.getAlign()); + Dyld.mapSectionAddress(Alloc.getLocalAddress(), NextCodeAddr); + DEBUG(dbgs() << " code: " + << static_cast<void *>(Alloc.getLocalAddress()) + << " -> " << format("0x%016x", NextCodeAddr) << "\n"); + Alloc.setRemoteAddress(NextCodeAddr); + NextCodeAddr += Alloc.getSize(); + } + } + { + TargetAddress NextRODataAddr = ObjAllocs.RemoteRODataAddr; + for (auto &Alloc : ObjAllocs.RODataAllocs) { + NextRODataAddr = + RoundUpToAlignment(NextRODataAddr, Alloc.getAlign()); + Dyld.mapSectionAddress(Alloc.getLocalAddress(), NextRODataAddr); + DEBUG(dbgs() << " ro-data: " + << static_cast<void *>(Alloc.getLocalAddress()) + << " -> " << format("0x%016x", NextRODataAddr) + << "\n"); + Alloc.setRemoteAddress(NextRODataAddr); + NextRODataAddr += Alloc.getSize(); + } + } + { + TargetAddress NextRWDataAddr = ObjAllocs.RemoteRWDataAddr; + for (auto &Alloc : ObjAllocs.RWDataAllocs) { + NextRWDataAddr = + RoundUpToAlignment(NextRWDataAddr, Alloc.getAlign()); + Dyld.mapSectionAddress(Alloc.getLocalAddress(), NextRWDataAddr); + DEBUG(dbgs() << " rw-data: " + << static_cast<void *>(Alloc.getLocalAddress()) + << " -> " << format("0x%016x", NextRWDataAddr) + << "\n"); + Alloc.setRemoteAddress(NextRWDataAddr); + NextRWDataAddr += Alloc.getSize(); + } + } + Unfinalized.push_back(std::move(ObjAllocs)); + } + Unmapped.clear(); + } + + bool finalizeMemory(std::string *ErrMsg = nullptr) override { + DEBUG(dbgs() << "Allocator " << Id << " finalizing:\n"); + + for (auto &ObjAllocs : Unfinalized) { + + for (auto &Alloc : ObjAllocs.CodeAllocs) { + DEBUG(dbgs() << " copying code: " + << static_cast<void *>(Alloc.getLocalAddress()) << " -> " + << format("0x%016x", Alloc.getRemoteAddress()) << " (" + << Alloc.getSize() << " bytes)\n"); + Client.writeMem(Alloc.getRemoteAddress(), Alloc.getLocalAddress(), + Alloc.getSize()); + } + + if (ObjAllocs.RemoteCodeAddr) { + DEBUG(dbgs() << " setting R-X permissions on code block: " + << format("0x%016x", ObjAllocs.RemoteCodeAddr) << "\n"); + Client.setProtections(Id, ObjAllocs.RemoteCodeAddr, + sys::Memory::MF_READ | sys::Memory::MF_EXEC); + } + + for (auto &Alloc : ObjAllocs.RODataAllocs) { + DEBUG(dbgs() << " copying ro-data: " + << static_cast<void *>(Alloc.getLocalAddress()) << " -> " + << format("0x%016x", Alloc.getRemoteAddress()) << " (" + << Alloc.getSize() << " bytes)\n"); + Client.writeMem(Alloc.getRemoteAddress(), Alloc.getLocalAddress(), + Alloc.getSize()); + } + + if (ObjAllocs.RemoteRODataAddr) { + DEBUG(dbgs() << " setting R-- permissions on ro-data block: " + << format("0x%016x", ObjAllocs.RemoteRODataAddr) + << "\n"); + Client.setProtections(Id, ObjAllocs.RemoteRODataAddr, + sys::Memory::MF_READ); + } + + for (auto &Alloc : ObjAllocs.RWDataAllocs) { + DEBUG(dbgs() << " copying rw-data: " + << static_cast<void *>(Alloc.getLocalAddress()) << " -> " + << format("0x%016x", Alloc.getRemoteAddress()) << " (" + << Alloc.getSize() << " bytes)\n"); + Client.writeMem(Alloc.getRemoteAddress(), Alloc.getLocalAddress(), + Alloc.getSize()); + } + + if (ObjAllocs.RemoteRWDataAddr) { + DEBUG(dbgs() << " setting RW- permissions on rw-data block: " + << format("0x%016x", ObjAllocs.RemoteRWDataAddr) + << "\n"); + Client.setProtections(Id, ObjAllocs.RemoteRWDataAddr, + sys::Memory::MF_READ | sys::Memory::MF_WRITE); + } + } + Unfinalized.clear(); + + return false; + } + + private: + class Alloc { + public: + Alloc(uint64_t Size, unsigned Align) + : Size(Size), Align(Align), Contents(new char[Size + Align - 1]), + RemoteAddr(0) {} + + Alloc(Alloc &&Other) + : Size(std::move(Other.Size)), Align(std::move(Other.Align)), + Contents(std::move(Other.Contents)), + RemoteAddr(std::move(Other.RemoteAddr)) {} + + Alloc &operator=(Alloc &&Other) { + Size = std::move(Other.Size); + Align = std::move(Other.Align); + Contents = std::move(Other.Contents); + RemoteAddr = std::move(Other.RemoteAddr); + return *this; + } + + uint64_t getSize() const { return Size; } + + unsigned getAlign() const { return Align; } + + char *getLocalAddress() const { + uintptr_t LocalAddr = reinterpret_cast<uintptr_t>(Contents.get()); + LocalAddr = RoundUpToAlignment(LocalAddr, Align); + return reinterpret_cast<char *>(LocalAddr); + } + + void setRemoteAddress(TargetAddress RemoteAddr) { + this->RemoteAddr = RemoteAddr; + } + + TargetAddress getRemoteAddress() const { return RemoteAddr; } + + private: + uint64_t Size; + unsigned Align; + std::unique_ptr<char[]> Contents; + TargetAddress RemoteAddr; + }; + + struct ObjectAllocs { + ObjectAllocs() + : RemoteCodeAddr(0), RemoteRODataAddr(0), RemoteRWDataAddr(0) {} + + ObjectAllocs(ObjectAllocs &&Other) + : RemoteCodeAddr(std::move(Other.RemoteCodeAddr)), + RemoteRODataAddr(std::move(Other.RemoteRODataAddr)), + RemoteRWDataAddr(std::move(Other.RemoteRWDataAddr)), + CodeAllocs(std::move(Other.CodeAllocs)), + RODataAllocs(std::move(Other.RODataAllocs)), + RWDataAllocs(std::move(Other.RWDataAllocs)) {} + + ObjectAllocs &operator=(ObjectAllocs &&Other) { + RemoteCodeAddr = std::move(Other.RemoteCodeAddr); + RemoteRODataAddr = std::move(Other.RemoteRODataAddr); + RemoteRWDataAddr = std::move(Other.RemoteRWDataAddr); + CodeAllocs = std::move(Other.CodeAllocs); + RODataAllocs = std::move(Other.RODataAllocs); + RWDataAllocs = std::move(Other.RWDataAllocs); + return *this; + } + + TargetAddress RemoteCodeAddr; + TargetAddress RemoteRODataAddr; + TargetAddress RemoteRWDataAddr; + std::vector<Alloc> CodeAllocs, RODataAllocs, RWDataAllocs; + }; + + OrcRemoteTargetClient &Client; + ResourceIdMgr::ResourceId Id; + std::vector<ObjectAllocs> Unmapped; + std::vector<ObjectAllocs> Unfinalized; + }; + + /// Remote indirect stubs manager. + class RCIndirectStubsManager : public IndirectStubsManager { + public: + RCIndirectStubsManager(OrcRemoteTargetClient &Remote, + ResourceIdMgr::ResourceId Id) + : Remote(Remote), Id(Id) {} + + ~RCIndirectStubsManager() { Remote.destroyIndirectStubsManager(Id); } + + std::error_code createStub(StringRef StubName, TargetAddress StubAddr, + JITSymbolFlags StubFlags) override { + if (auto EC = reserveStubs(1)) + return EC; + + return createStubInternal(StubName, StubAddr, StubFlags); + } + + std::error_code createStubs(const StubInitsMap &StubInits) override { + if (auto EC = reserveStubs(StubInits.size())) + return EC; + + for (auto &Entry : StubInits) + if (auto EC = createStubInternal(Entry.first(), Entry.second.first, + Entry.second.second)) + return EC; + + return std::error_code(); + } + + JITSymbol findStub(StringRef Name, bool ExportedStubsOnly) override { + auto I = StubIndexes.find(Name); + if (I == StubIndexes.end()) + return nullptr; + auto Key = I->second.first; + auto Flags = I->second.second; + auto StubSymbol = JITSymbol(getStubAddr(Key), Flags); + if (ExportedStubsOnly && !StubSymbol.isExported()) + return nullptr; + return StubSymbol; + } + + JITSymbol findPointer(StringRef Name) override { + auto I = StubIndexes.find(Name); + if (I == StubIndexes.end()) + return nullptr; + auto Key = I->second.first; + auto Flags = I->second.second; + return JITSymbol(getPtrAddr(Key), Flags); + } + + std::error_code updatePointer(StringRef Name, + TargetAddress NewAddr) override { + auto I = StubIndexes.find(Name); + assert(I != StubIndexes.end() && "No stub pointer for symbol"); + auto Key = I->second.first; + return Remote.writePointer(getPtrAddr(Key), NewAddr); + } + + private: + struct RemoteIndirectStubsInfo { + RemoteIndirectStubsInfo(TargetAddress StubBase, TargetAddress PtrBase, + unsigned NumStubs) + : StubBase(StubBase), PtrBase(PtrBase), NumStubs(NumStubs) {} + TargetAddress StubBase; + TargetAddress PtrBase; + unsigned NumStubs; + }; + + OrcRemoteTargetClient &Remote; + ResourceIdMgr::ResourceId Id; + std::vector<RemoteIndirectStubsInfo> RemoteIndirectStubsInfos; + typedef std::pair<uint16_t, uint16_t> StubKey; + std::vector<StubKey> FreeStubs; + StringMap<std::pair<StubKey, JITSymbolFlags>> StubIndexes; + + std::error_code reserveStubs(unsigned NumStubs) { + if (NumStubs <= FreeStubs.size()) + return std::error_code(); + + unsigned NewStubsRequired = NumStubs - FreeStubs.size(); + TargetAddress StubBase; + TargetAddress PtrBase; + unsigned NumStubsEmitted; + + Remote.emitIndirectStubs(StubBase, PtrBase, NumStubsEmitted, Id, + NewStubsRequired); + + unsigned NewBlockId = RemoteIndirectStubsInfos.size(); + RemoteIndirectStubsInfos.push_back( + RemoteIndirectStubsInfo(StubBase, PtrBase, NumStubsEmitted)); + + for (unsigned I = 0; I < NumStubsEmitted; ++I) + FreeStubs.push_back(std::make_pair(NewBlockId, I)); + + return std::error_code(); + } + + std::error_code createStubInternal(StringRef StubName, + TargetAddress InitAddr, + JITSymbolFlags StubFlags) { + auto Key = FreeStubs.back(); + FreeStubs.pop_back(); + StubIndexes[StubName] = std::make_pair(Key, StubFlags); + return Remote.writePointer(getPtrAddr(Key), InitAddr); + } + + TargetAddress getStubAddr(StubKey K) { + assert(RemoteIndirectStubsInfos[K.first].StubBase != 0 && + "Missing stub address"); + return RemoteIndirectStubsInfos[K.first].StubBase + + K.second * Remote.getIndirectStubSize(); + } + + TargetAddress getPtrAddr(StubKey K) { + assert(RemoteIndirectStubsInfos[K.first].PtrBase != 0 && + "Missing pointer address"); + return RemoteIndirectStubsInfos[K.first].PtrBase + + K.second * Remote.getPointerSize(); + } + }; + + /// Remote compile callback manager. + class RCCompileCallbackManager : public JITCompileCallbackManager { + public: + RCCompileCallbackManager(TargetAddress ErrorHandlerAddress, + OrcRemoteTargetClient &Remote) + : JITCompileCallbackManager(ErrorHandlerAddress), Remote(Remote) { + assert(!Remote.CompileCallback && "Compile callback already set"); + Remote.CompileCallback = [this](TargetAddress TrampolineAddr) { + return executeCompileCallback(TrampolineAddr); + }; + Remote.emitResolverBlock(); + } + + private: + void grow() { + TargetAddress BlockAddr = 0; + uint32_t NumTrampolines = 0; + auto EC = Remote.emitTrampolineBlock(BlockAddr, NumTrampolines); + assert(!EC && "Failed to create trampolines"); + + uint32_t TrampolineSize = Remote.getTrampolineSize(); + for (unsigned I = 0; I < NumTrampolines; ++I) + this->AvailableTrampolines.push_back(BlockAddr + (I * TrampolineSize)); + } + + OrcRemoteTargetClient &Remote; + }; + + /// Create an OrcRemoteTargetClient. + /// Channel is the ChannelT instance to communicate on. It is assumed that + /// the channel is ready to be read from and written to. + static ErrorOr<OrcRemoteTargetClient> Create(ChannelT &Channel) { + std::error_code EC; + OrcRemoteTargetClient H(Channel, EC); + if (EC) + return EC; + return H; + } + + /// Call the int(void) function at the given address in the target and return + /// its result. + std::error_code callIntVoid(int &Result, TargetAddress Addr) { + DEBUG(dbgs() << "Calling int(*)(void) " << format("0x%016x", Addr) << "\n"); + + if (auto EC = call<CallIntVoid>(Channel, Addr)) + return EC; + + unsigned NextProcId; + if (auto EC = listenForCompileRequests(NextProcId)) + return EC; + + if (NextProcId != CallIntVoidResponseId) + return orcError(OrcErrorCode::UnexpectedRPCCall); + + return handle<CallIntVoidResponse>(Channel, [&](int R) { + Result = R; + DEBUG(dbgs() << "Result: " << R << "\n"); + return std::error_code(); + }); + } + + /// Call the int(int, char*[]) function at the given address in the target and + /// return its result. + std::error_code callMain(int &Result, TargetAddress Addr, + const std::vector<std::string> &Args) { + DEBUG(dbgs() << "Calling int(*)(int, char*[]) " << format("0x%016x", Addr) + << "\n"); + + if (auto EC = call<CallMain>(Channel, Addr, Args)) + return EC; + + unsigned NextProcId; + if (auto EC = listenForCompileRequests(NextProcId)) + return EC; + + if (NextProcId != CallMainResponseId) + return orcError(OrcErrorCode::UnexpectedRPCCall); + + return handle<CallMainResponse>(Channel, [&](int R) { + Result = R; + DEBUG(dbgs() << "Result: " << R << "\n"); + return std::error_code(); + }); + } + + /// Call the void() function at the given address in the target and wait for + /// it to finish. + std::error_code callVoidVoid(TargetAddress Addr) { + DEBUG(dbgs() << "Calling void(*)(void) " << format("0x%016x", Addr) + << "\n"); + + if (auto EC = call<CallVoidVoid>(Channel, Addr)) + return EC; + + unsigned NextProcId; + if (auto EC = listenForCompileRequests(NextProcId)) + return EC; + + if (NextProcId != CallVoidVoidResponseId) + return orcError(OrcErrorCode::UnexpectedRPCCall); + + return handle<CallVoidVoidResponse>(Channel, doNothing); + } + + /// Create an RCMemoryManager which will allocate its memory on the remote + /// target. + std::error_code + createRemoteMemoryManager(std::unique_ptr<RCMemoryManager> &MM) { + assert(!MM && "MemoryManager should be null before creation."); + + auto Id = AllocatorIds.getNext(); + if (auto EC = call<CreateRemoteAllocator>(Channel, Id)) + return EC; + MM = llvm::make_unique<RCMemoryManager>(*this, Id); + return std::error_code(); + } + + /// Create an RCIndirectStubsManager that will allocate stubs on the remote + /// target. + std::error_code + createIndirectStubsManager(std::unique_ptr<RCIndirectStubsManager> &I) { + assert(!I && "Indirect stubs manager should be null before creation."); + auto Id = IndirectStubOwnerIds.getNext(); + if (auto EC = call<CreateIndirectStubsOwner>(Channel, Id)) + return EC; + I = llvm::make_unique<RCIndirectStubsManager>(*this, Id); + return std::error_code(); + } + + /// Search for symbols in the remote process. Note: This should be used by + /// symbol resolvers *after* they've searched the local symbol table in the + /// JIT stack. + std::error_code getSymbolAddress(TargetAddress &Addr, StringRef Name) { + // Check for an 'out-of-band' error, e.g. from an MM destructor. + if (ExistingError) + return ExistingError; + + // Request remote symbol address. + if (auto EC = call<GetSymbolAddress>(Channel, Name)) + return EC; + + return expect<GetSymbolAddressResponse>(Channel, [&](TargetAddress &A) { + Addr = A; + DEBUG(dbgs() << "Remote address lookup " << Name << " = " + << format("0x%016x", Addr) << "\n"); + return std::error_code(); + }); + } + + /// Get the triple for the remote target. + const std::string &getTargetTriple() const { return RemoteTargetTriple; } + + std::error_code terminateSession() { return call<TerminateSession>(Channel); } + +private: + OrcRemoteTargetClient(ChannelT &Channel, std::error_code &EC) + : Channel(Channel), RemotePointerSize(0), RemotePageSize(0), + RemoteTrampolineSize(0), RemoteIndirectStubSize(0) { + if ((EC = call<GetRemoteInfo>(Channel))) + return; + + EC = expect<GetRemoteInfoResponse>( + Channel, readArgs(RemoteTargetTriple, RemotePointerSize, RemotePageSize, + RemoteTrampolineSize, RemoteIndirectStubSize)); + } + + void destroyRemoteAllocator(ResourceIdMgr::ResourceId Id) { + if (auto EC = call<DestroyRemoteAllocator>(Channel, Id)) { + // FIXME: This will be triggered by a removeModuleSet call: Propagate + // error return up through that. + llvm_unreachable("Failed to destroy remote allocator."); + AllocatorIds.release(Id); + } + } + + std::error_code destroyIndirectStubsManager(ResourceIdMgr::ResourceId Id) { + IndirectStubOwnerIds.release(Id); + return call<DestroyIndirectStubsOwner>(Channel, Id); + } + + std::error_code emitIndirectStubs(TargetAddress &StubBase, + TargetAddress &PtrBase, + uint32_t &NumStubsEmitted, + ResourceIdMgr::ResourceId Id, + uint32_t NumStubsRequired) { + if (auto EC = call<EmitIndirectStubs>(Channel, Id, NumStubsRequired)) + return EC; + + return expect<EmitIndirectStubsResponse>( + Channel, readArgs(StubBase, PtrBase, NumStubsEmitted)); + } + + std::error_code emitResolverBlock() { + // Check for an 'out-of-band' error, e.g. from an MM destructor. + if (ExistingError) + return ExistingError; + + return call<EmitResolverBlock>(Channel); + } + + std::error_code emitTrampolineBlock(TargetAddress &BlockAddr, + uint32_t &NumTrampolines) { + // Check for an 'out-of-band' error, e.g. from an MM destructor. + if (ExistingError) + return ExistingError; + + if (auto EC = call<EmitTrampolineBlock>(Channel)) + return EC; + + return expect<EmitTrampolineBlockResponse>( + Channel, [&](TargetAddress BAddr, uint32_t NTrampolines) { + BlockAddr = BAddr; + NumTrampolines = NTrampolines; + return std::error_code(); + }); + } + + uint32_t getIndirectStubSize() const { return RemoteIndirectStubSize; } + uint32_t getPageSize() const { return RemotePageSize; } + uint32_t getPointerSize() const { return RemotePointerSize; } + + uint32_t getTrampolineSize() const { return RemoteTrampolineSize; } + + std::error_code listenForCompileRequests(uint32_t &NextId) { + // Check for an 'out-of-band' error, e.g. from an MM destructor. + if (ExistingError) + return ExistingError; + + if (auto EC = getNextProcId(Channel, NextId)) + return EC; + + while (NextId == RequestCompileId) { + TargetAddress TrampolineAddr = 0; + if (auto EC = handle<RequestCompile>(Channel, readArgs(TrampolineAddr))) + return EC; + + TargetAddress ImplAddr = CompileCallback(TrampolineAddr); + if (auto EC = call<RequestCompileResponse>(Channel, ImplAddr)) + return EC; + + if (auto EC = getNextProcId(Channel, NextId)) + return EC; + } + + return std::error_code(); + } + + std::error_code readMem(char *Dst, TargetAddress Src, uint64_t Size) { + // Check for an 'out-of-band' error, e.g. from an MM destructor. + if (ExistingError) + return ExistingError; + + if (auto EC = call<ReadMem>(Channel, Src, Size)) + return EC; + + if (auto EC = expect<ReadMemResponse>( + Channel, [&]() { return Channel.readBytes(Dst, Size); })) + return EC; + + return std::error_code(); + } + + std::error_code reserveMem(TargetAddress &RemoteAddr, + ResourceIdMgr::ResourceId Id, uint64_t Size, + uint32_t Align) { + + // Check for an 'out-of-band' error, e.g. from an MM destructor. + if (ExistingError) + return ExistingError; + + if (std::error_code EC = call<ReserveMem>(Channel, Id, Size, Align)) + return EC; + + return expect<ReserveMemResponse>(Channel, readArgs(RemoteAddr)); + } + + std::error_code setProtections(ResourceIdMgr::ResourceId Id, + TargetAddress RemoteSegAddr, + unsigned ProtFlags) { + return call<SetProtections>(Channel, Id, RemoteSegAddr, ProtFlags); + } + + std::error_code writeMem(TargetAddress Addr, const char *Src, uint64_t Size) { + // Check for an 'out-of-band' error, e.g. from an MM destructor. + if (ExistingError) + return ExistingError; + + // Make the send call. + if (auto EC = call<WriteMem>(Channel, Addr, Size)) + return EC; + + // Follow this up with the section contents. + if (auto EC = Channel.appendBytes(Src, Size)) + return EC; + + return Channel.send(); + } + + std::error_code writePointer(TargetAddress Addr, TargetAddress PtrVal) { + // Check for an 'out-of-band' error, e.g. from an MM destructor. + if (ExistingError) + return ExistingError; + + return call<WritePtr>(Channel, Addr, PtrVal); + } + + static std::error_code doNothing() { return std::error_code(); } + + ChannelT &Channel; + std::error_code ExistingError; + std::string RemoteTargetTriple; + uint32_t RemotePointerSize; + uint32_t RemotePageSize; + uint32_t RemoteTrampolineSize; + uint32_t RemoteIndirectStubSize; + ResourceIdMgr AllocatorIds, IndirectStubOwnerIds; + std::function<TargetAddress(TargetAddress)> CompileCallback; +}; + +} // end namespace remote +} // end namespace orc +} // end namespace llvm + +#undef DEBUG_TYPE + +#endif |
