nils.hoelscher
/
llvm-for-llvmta
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
llvm-for-llvmta/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h

926 lines
33 KiB
C
Raw Permalink Normal View History

first commit
2022-04-25 10:02:23 +02:00
//===- OrcRemoteTargetClient.h - Orc Remote-target Client -------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the OrcRemoteTargetClient class and helpers. This class
// can be used to communicate over an RawByteChannel with an
// OrcRemoteTargetServer instance to support remote-JITing.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETCLIENT_H
#define LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETCLIENT_H
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
#include "llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h"
#include "llvm/ExecutionEngine/RuntimeDyld.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/Memory.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <memory>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#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.
class OrcRemoteTargetClient
: public shared::SingleThreadedRPCEndpoint<shared::RawByteChannel> {
public:
/// Remote-mapped RuntimeDyld-compatible memory manager.
class RemoteRTDyldMemoryManager : public RuntimeDyld::MemoryManager {
friend class OrcRemoteTargetClient;
public:
~RemoteRTDyldMemoryManager() {
Client.destroyRemoteAllocator(Id);
LLVM_DEBUG(dbgs() << "Destroyed remote allocator " << Id << "\n");
}
RemoteRTDyldMemoryManager(const RemoteRTDyldMemoryManager &) = delete;
RemoteRTDyldMemoryManager &
operator=(const RemoteRTDyldMemoryManager &) = delete;
RemoteRTDyldMemoryManager(RemoteRTDyldMemoryManager &&) = default;
RemoteRTDyldMemoryManager &operator=(RemoteRTDyldMemoryManager &&) = delete;
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());
LLVM_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());
LLVM_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());
LLVM_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());
LLVM_DEBUG(dbgs() << "Allocator " << Id << " reserved:\n");
if (CodeSize != 0) {
Unmapped.back().RemoteCodeAddr =
Client.reserveMem(Id, CodeSize, CodeAlign);
LLVM_DEBUG(
dbgs() << " code: "
<< format("0x%016" PRIx64, Unmapped.back().RemoteCodeAddr)
<< " (" << CodeSize << " bytes, alignment " << CodeAlign
<< ")\n");
}
if (RODataSize != 0) {
Unmapped.back().RemoteRODataAddr =
Client.reserveMem(Id, RODataSize, RODataAlign);
LLVM_DEBUG(
dbgs() << " ro-data: "
<< format("0x%016" PRIx64, Unmapped.back().RemoteRODataAddr)
<< " (" << RODataSize << " bytes, alignment " << RODataAlign
<< ")\n");
}
if (RWDataSize != 0) {
Unmapped.back().RemoteRWDataAddr =
Client.reserveMem(Id, RWDataSize, RWDataAlign);
LLVM_DEBUG(
dbgs() << " rw-data: "
<< format("0x%016" PRIx64, 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 {
UnfinalizedEHFrames.push_back({LoadAddr, Size});
}
void deregisterEHFrames() override {
for (auto &Frame : RegisteredEHFrames) {
// FIXME: Add error poll.
Client.deregisterEHFrames(Frame.Addr, Frame.Size);
}
}
void notifyObjectLoaded(RuntimeDyld &Dyld,
const object::ObjectFile &Obj) override {
LLVM_DEBUG(dbgs() << "Allocator " << Id << " applied mappings:\n");
for (auto &ObjAllocs : Unmapped) {
mapAllocsToRemoteAddrs(Dyld, ObjAllocs.CodeAllocs,
ObjAllocs.RemoteCodeAddr);
mapAllocsToRemoteAddrs(Dyld, ObjAllocs.RODataAllocs,
ObjAllocs.RemoteRODataAddr);
mapAllocsToRemoteAddrs(Dyld, ObjAllocs.RWDataAllocs,
ObjAllocs.RemoteRWDataAddr);
Unfinalized.push_back(std::move(ObjAllocs));
}
Unmapped.clear();
}
bool finalizeMemory(std::string *ErrMsg = nullptr) override {
LLVM_DEBUG(dbgs() << "Allocator " << Id << " finalizing:\n");
for (auto &ObjAllocs : Unfinalized) {
if (copyAndProtect(ObjAllocs.CodeAllocs, ObjAllocs.RemoteCodeAddr,
sys::Memory::MF_READ | sys::Memory::MF_EXEC))
return true;
if (copyAndProtect(ObjAllocs.RODataAllocs, ObjAllocs.RemoteRODataAddr,
sys::Memory::MF_READ))
return true;
if (copyAndProtect(ObjAllocs.RWDataAllocs, ObjAllocs.RemoteRWDataAddr,
sys::Memory::MF_READ | sys::Memory::MF_WRITE))
return true;
}
Unfinalized.clear();
for (auto &EHFrame : UnfinalizedEHFrames) {
if (auto Err = Client.registerEHFrames(EHFrame.Addr, EHFrame.Size)) {
// FIXME: Replace this once finalizeMemory can return an Error.
handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
if (ErrMsg) {
raw_string_ostream ErrOut(*ErrMsg);
EIB.log(ErrOut);
}
});
return false;
}
}
RegisteredEHFrames = std::move(UnfinalizedEHFrames);
UnfinalizedEHFrames = {};
return false;
}
private:
class Alloc {
public:
Alloc(uint64_t Size, unsigned Align)
: Size(Size), Align(Align), Contents(new char[Size + Align - 1]) {}
Alloc(const Alloc &) = delete;
Alloc &operator=(const Alloc &) = delete;
Alloc(Alloc &&) = default;
Alloc &operator=(Alloc &&) = default;
uint64_t getSize() const { return Size; }
unsigned getAlign() const { return Align; }
char *getLocalAddress() const {
uintptr_t LocalAddr = reinterpret_cast<uintptr_t>(Contents.get());
LocalAddr = alignTo(LocalAddr, Align);
return reinterpret_cast<char *>(LocalAddr);
}
void setRemoteAddress(JITTargetAddress RemoteAddr) {
this->RemoteAddr = RemoteAddr;
}
JITTargetAddress getRemoteAddress() const { return RemoteAddr; }
private:
uint64_t Size;
unsigned Align;
std::unique_ptr<char[]> Contents;
JITTargetAddress RemoteAddr = 0;
};
struct ObjectAllocs {
ObjectAllocs() = default;
ObjectAllocs(const ObjectAllocs &) = delete;
ObjectAllocs &operator=(const ObjectAllocs &) = delete;
ObjectAllocs(ObjectAllocs &&) = default;
ObjectAllocs &operator=(ObjectAllocs &&) = default;
JITTargetAddress RemoteCodeAddr = 0;
JITTargetAddress RemoteRODataAddr = 0;
JITTargetAddress RemoteRWDataAddr = 0;
std::vector<Alloc> CodeAllocs, RODataAllocs, RWDataAllocs;
};
RemoteRTDyldMemoryManager(OrcRemoteTargetClient &Client,
ResourceIdMgr::ResourceId Id)
: Client(Client), Id(Id) {
LLVM_DEBUG(dbgs() << "Created remote allocator " << Id << "\n");
}
// Maps all allocations in Allocs to aligned blocks
void mapAllocsToRemoteAddrs(RuntimeDyld &Dyld, std::vector<Alloc> &Allocs,
JITTargetAddress NextAddr) {
for (auto &Alloc : Allocs) {
NextAddr = alignTo(NextAddr, Alloc.getAlign());
Dyld.mapSectionAddress(Alloc.getLocalAddress(), NextAddr);
LLVM_DEBUG(
dbgs() << " " << static_cast<void *>(Alloc.getLocalAddress())
<< " -> " << format("0x%016" PRIx64, NextAddr) << "\n");
Alloc.setRemoteAddress(NextAddr);
// Only advance NextAddr if it was non-null to begin with,
// otherwise leave it as null.
if (NextAddr)
NextAddr += Alloc.getSize();
}
}
// Copies data for each alloc in the list, then set permissions on the
// segment.
bool copyAndProtect(const std::vector<Alloc> &Allocs,
JITTargetAddress RemoteSegmentAddr,
unsigned Permissions) {
if (RemoteSegmentAddr) {
assert(!Allocs.empty() && "No sections in allocated segment");
for (auto &Alloc : Allocs) {
LLVM_DEBUG(dbgs() << " copying section: "
<< static_cast<void *>(Alloc.getLocalAddress())
<< " -> "
<< format("0x%016" PRIx64, Alloc.getRemoteAddress())
<< " (" << Alloc.getSize() << " bytes)\n";);
if (Client.writeMem(Alloc.getRemoteAddress(), Alloc.getLocalAddress(),
Alloc.getSize()))
return true;
}
LLVM_DEBUG(dbgs() << " setting "
<< (Permissions & sys::Memory::MF_READ ? 'R' : '-')
<< (Permissions & sys::Memory::MF_WRITE ? 'W' : '-')
<< (Permissions & sys::Memory::MF_EXEC ? 'X' : '-')
<< " permissions on block: "
<< format("0x%016" PRIx64, RemoteSegmentAddr)
<< "\n");
if (Client.setProtections(Id, RemoteSegmentAddr, Permissions))
return true;
}
return false;
}
OrcRemoteTargetClient &Client;
ResourceIdMgr::ResourceId Id;
std::vector<ObjectAllocs> Unmapped;
std::vector<ObjectAllocs> Unfinalized;
struct EHFrame {
JITTargetAddress Addr;
uint64_t Size;
};
std::vector<EHFrame> UnfinalizedEHFrames;
std::vector<EHFrame> RegisteredEHFrames;
};
class RPCMMAlloc : public jitlink::JITLinkMemoryManager::Allocation {
using AllocationMap = DenseMap<unsigned, sys::MemoryBlock>;
using FinalizeContinuation =
jitlink::JITLinkMemoryManager::Allocation::FinalizeContinuation;
using ProtectionFlags = sys::Memory::ProtectionFlags;
using SegmentsRequestMap =
DenseMap<unsigned, jitlink::JITLinkMemoryManager::SegmentRequest>;
RPCMMAlloc(OrcRemoteTargetClient &Client, ResourceIdMgr::ResourceId Id)
: Client(Client), Id(Id) {}
public:
static Expected<std::unique_ptr<RPCMMAlloc>>
Create(OrcRemoteTargetClient &Client, ResourceIdMgr::ResourceId Id,
const SegmentsRequestMap &Request) {
auto *MM = new RPCMMAlloc(Client, Id);
if (Error Err = MM->allocateHostBlocks(Request))
return std::move(Err);
if (Error Err = MM->allocateTargetBlocks())
return std::move(Err);
return std::unique_ptr<RPCMMAlloc>(MM);
}
MutableArrayRef<char> getWorkingMemory(ProtectionFlags Seg) override {
assert(HostSegBlocks.count(Seg) && "No allocation for segment");
return {static_cast<char *>(HostSegBlocks[Seg].base()),
HostSegBlocks[Seg].allocatedSize()};
}
JITTargetAddress getTargetMemory(ProtectionFlags Seg) override {
assert(TargetSegBlocks.count(Seg) && "No allocation for segment");
return pointerToJITTargetAddress(TargetSegBlocks[Seg].base());
}
void finalizeAsync(FinalizeContinuation OnFinalize) override {
// Host allocations (working memory) remain ReadWrite.
OnFinalize(copyAndProtect());
}
Error deallocate() override {
// TODO: Cannot release target allocation. RPCAPI has no function
// symmetric to reserveMem(). Add RPC call like freeMem()?
return errorCodeToError(sys::Memory::releaseMappedMemory(HostAllocation));
}
private:
OrcRemoteTargetClient &Client;
ResourceIdMgr::ResourceId Id;
AllocationMap HostSegBlocks;
AllocationMap TargetSegBlocks;
JITTargetAddress TargetSegmentAddr;
sys::MemoryBlock HostAllocation;
Error allocateHostBlocks(const SegmentsRequestMap &Request) {
unsigned TargetPageSize = Client.getPageSize();
if (!isPowerOf2_64(static_cast<uint64_t>(TargetPageSize)))
return make_error<StringError>("Host page size is not a power of 2",
inconvertibleErrorCode());
auto TotalSize = calcTotalAllocSize(Request, TargetPageSize);
if (!TotalSize)
return TotalSize.takeError();
// Allocate one slab to cover all the segments.
const sys::Memory::ProtectionFlags ReadWrite =
static_cast<sys::Memory::ProtectionFlags>(sys::Memory::MF_READ |
sys::Memory::MF_WRITE);
std::error_code EC;
HostAllocation =
sys::Memory::allocateMappedMemory(*TotalSize, nullptr, ReadWrite, EC);
if (EC)
return errorCodeToError(EC);
char *SlabAddr = static_cast<char *>(HostAllocation.base());
#ifndef NDEBUG
char *SlabAddrEnd = SlabAddr + HostAllocation.allocatedSize();
#endif
// Allocate segment memory from the slab.
for (auto &KV : Request) {
const auto &Seg = KV.second;
uint64_t SegmentSize = Seg.getContentSize() + Seg.getZeroFillSize();
uint64_t AlignedSegmentSize = alignTo(SegmentSize, TargetPageSize);
// Zero out zero-fill memory.
char *ZeroFillBegin = SlabAddr + Seg.getContentSize();
memset(ZeroFillBegin, 0, Seg.getZeroFillSize());
// Record the block for this segment.
HostSegBlocks[KV.first] =
sys::MemoryBlock(SlabAddr, AlignedSegmentSize);
SlabAddr += AlignedSegmentSize;
assert(SlabAddr <= SlabAddrEnd && "Out of range");
}
return Error::success();
}
Error allocateTargetBlocks() {
// Reserve memory for all blocks on the target. We need as much space on
// the target as we allocated on the host.
TargetSegmentAddr = Client.reserveMem(Id, HostAllocation.allocatedSize(),
Client.getPageSize());
if (!TargetSegmentAddr)
return make_error<StringError>("Failed to reserve memory on the target",
inconvertibleErrorCode());
// Map memory blocks into the allocation, that match the host allocation.
JITTargetAddress TargetAllocAddr = TargetSegmentAddr;
for (const auto &KV : HostSegBlocks) {
size_t TargetAllocSize = KV.second.allocatedSize();
TargetSegBlocks[KV.first] =
sys::MemoryBlock(jitTargetAddressToPointer<void *>(TargetAllocAddr),
TargetAllocSize);
TargetAllocAddr += TargetAllocSize;
assert(TargetAllocAddr - TargetSegmentAddr <=
HostAllocation.allocatedSize() &&
"Out of range on target");
}
return Error::success();
}
Error copyAndProtect() {
unsigned Permissions = 0u;
// Copy segments one by one.
for (auto &KV : TargetSegBlocks) {
Permissions |= KV.first;
const sys::MemoryBlock &TargetBlock = KV.second;
const sys::MemoryBlock &HostBlock = HostSegBlocks.lookup(KV.first);
size_t TargetAllocSize = TargetBlock.allocatedSize();
auto TargetAllocAddr = pointerToJITTargetAddress(TargetBlock.base());
auto *HostAllocBegin = static_cast<const char *>(HostBlock.base());
bool CopyErr =
Client.writeMem(TargetAllocAddr, HostAllocBegin, TargetAllocSize);
if (CopyErr)
return createStringError(inconvertibleErrorCode(),
"Failed to copy %d segment to the target",
KV.first);
}
// Set permission flags for all segments at once.
bool ProtectErr =
Client.setProtections(Id, TargetSegmentAddr, Permissions);
if (ProtectErr)
return createStringError(inconvertibleErrorCode(),
"Failed to apply permissions for %d segment "
"on the target",
Permissions);
return Error::success();
}
static Expected<size_t>
calcTotalAllocSize(const SegmentsRequestMap &Request,
unsigned TargetPageSize) {
size_t TotalSize = 0;
for (const auto &KV : Request) {
const auto &Seg = KV.second;
if (Seg.getAlignment() > TargetPageSize)
return make_error<StringError>("Cannot request alignment higher than "
"page alignment on target",
inconvertibleErrorCode());
TotalSize = alignTo(TotalSize, TargetPageSize);
TotalSize += Seg.getContentSize();
TotalSize += Seg.getZeroFillSize();
}
return TotalSize;
}
};
class RemoteJITLinkMemoryManager : public jitlink::JITLinkMemoryManager {
public:
RemoteJITLinkMemoryManager(OrcRemoteTargetClient &Client,
ResourceIdMgr::ResourceId Id)
: Client(Client), Id(Id) {}
RemoteJITLinkMemoryManager(const RemoteJITLinkMemoryManager &) = delete;
RemoteJITLinkMemoryManager(RemoteJITLinkMemoryManager &&) = default;
RemoteJITLinkMemoryManager &
operator=(const RemoteJITLinkMemoryManager &) = delete;
RemoteJITLinkMemoryManager &
operator=(RemoteJITLinkMemoryManager &&) = delete;
~RemoteJITLinkMemoryManager() {
Client.destroyRemoteAllocator(Id);
LLVM_DEBUG(dbgs() << "Destroyed remote allocator " << Id << "\n");
}
Expected<std::unique_ptr<Allocation>>
allocate(const jitlink::JITLinkDylib *JD,
const SegmentsRequestMap &Request) override {
return RPCMMAlloc::Create(Client, Id, Request);
}
private:
OrcRemoteTargetClient &Client;
ResourceIdMgr::ResourceId Id;
};
/// Remote indirect stubs manager.
class RemoteIndirectStubsManager : public IndirectStubsManager {
public:
RemoteIndirectStubsManager(OrcRemoteTargetClient &Client,
ResourceIdMgr::ResourceId Id)
: Client(Client), Id(Id) {}
~RemoteIndirectStubsManager() override {
Client.destroyIndirectStubsManager(Id);
}
Error createStub(StringRef StubName, JITTargetAddress StubAddr,
JITSymbolFlags StubFlags) override {
if (auto Err = reserveStubs(1))
return Err;
return createStubInternal(StubName, StubAddr, StubFlags);
}
Error createStubs(const StubInitsMap &StubInits) override {
if (auto Err = reserveStubs(StubInits.size()))
return Err;
for (auto &Entry : StubInits)
if (auto Err = createStubInternal(Entry.first(), Entry.second.first,
Entry.second.second))
return Err;
return Error::success();
}
JITEvaluatedSymbol 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 = JITEvaluatedSymbol(getStubAddr(Key), Flags);
if (ExportedStubsOnly && !StubSymbol.getFlags().isExported())
return nullptr;
return StubSymbol;
}
JITEvaluatedSymbol 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 JITEvaluatedSymbol(getPtrAddr(Key), Flags);
}
Error updatePointer(StringRef Name, JITTargetAddress NewAddr) override {
auto I = StubIndexes.find(Name);
assert(I != StubIndexes.end() && "No stub pointer for symbol");
auto Key = I->second.first;
return Client.writePointer(getPtrAddr(Key), NewAddr);
}
private:
struct RemoteIndirectStubsInfo {
JITTargetAddress StubBase;
JITTargetAddress PtrBase;
unsigned NumStubs;
};
using StubKey = std::pair<uint16_t, uint16_t>;
Error reserveStubs(unsigned NumStubs) {
if (NumStubs <= FreeStubs.size())
return Error::success();
unsigned NewStubsRequired = NumStubs - FreeStubs.size();
JITTargetAddress StubBase;
JITTargetAddress PtrBase;
unsigned NumStubsEmitted;
if (auto StubInfoOrErr = Client.emitIndirectStubs(Id, NewStubsRequired))
std::tie(StubBase, PtrBase, NumStubsEmitted) = *StubInfoOrErr;
else
return StubInfoOrErr.takeError();
unsigned NewBlockId = RemoteIndirectStubsInfos.size();
RemoteIndirectStubsInfos.push_back({StubBase, PtrBase, NumStubsEmitted});
for (unsigned I = 0; I < NumStubsEmitted; ++I)
FreeStubs.push_back(std::make_pair(NewBlockId, I));
return Error::success();
}
Error createStubInternal(StringRef StubName, JITTargetAddress InitAddr,
JITSymbolFlags StubFlags) {
auto Key = FreeStubs.back();
FreeStubs.pop_back();
StubIndexes[StubName] = std::make_pair(Key, StubFlags);
return Client.writePointer(getPtrAddr(Key), InitAddr);
}
JITTargetAddress getStubAddr(StubKey K) {
assert(RemoteIndirectStubsInfos[K.first].StubBase != 0 &&
"Missing stub address");
return RemoteIndirectStubsInfos[K.first].StubBase +
K.second * Client.getIndirectStubSize();
}
JITTargetAddress getPtrAddr(StubKey K) {
assert(RemoteIndirectStubsInfos[K.first].PtrBase != 0 &&
"Missing pointer address");
return RemoteIndirectStubsInfos[K.first].PtrBase +
K.second * Client.getPointerSize();
}
OrcRemoteTargetClient &Client;
ResourceIdMgr::ResourceId Id;
std::vector<RemoteIndirectStubsInfo> RemoteIndirectStubsInfos;
std::vector<StubKey> FreeStubs;
StringMap<std::pair<StubKey, JITSymbolFlags>> StubIndexes;
};
class RemoteTrampolinePool : public TrampolinePool {
public:
RemoteTrampolinePool(OrcRemoteTargetClient &Client) : Client(Client) {}
private:
Error grow() override {
JITTargetAddress BlockAddr = 0;
uint32_t NumTrampolines = 0;
if (auto TrampolineInfoOrErr = Client.emitTrampolineBlock())
std::tie(BlockAddr, NumTrampolines) = *TrampolineInfoOrErr;
else
return TrampolineInfoOrErr.takeError();
uint32_t TrampolineSize = Client.getTrampolineSize();
for (unsigned I = 0; I < NumTrampolines; ++I)
AvailableTrampolines.push_back(BlockAddr + (I * TrampolineSize));
return Error::success();
}
OrcRemoteTargetClient &Client;
};
/// Remote compile callback manager.
class RemoteCompileCallbackManager : public JITCompileCallbackManager {
public:
RemoteCompileCallbackManager(OrcRemoteTargetClient &Client,
ExecutionSession &ES,
JITTargetAddress ErrorHandlerAddress)
: JITCompileCallbackManager(
std::make_unique<RemoteTrampolinePool>(Client), ES,
ErrorHandlerAddress) {}
};
/// 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 Expected<std::unique_ptr<OrcRemoteTargetClient>>
Create(shared::RawByteChannel &Channel, ExecutionSession &ES) {
Error Err = Error::success();
auto Client = std::unique_ptr<OrcRemoteTargetClient>(
new OrcRemoteTargetClient(Channel, ES, Err));
if (Err)
return std::move(Err);
return std::move(Client);
}
/// Call the int(void) function at the given address in the target and return
/// its result.
Expected<int> callIntVoid(JITTargetAddress Addr) {
LLVM_DEBUG(dbgs() << "Calling int(*)(void) "
<< format("0x%016" PRIx64, Addr) << "\n");
return callB<exec::CallIntVoid>(Addr);
}
/// Call the int(int) function at the given address in the target and return
/// its result.
Expected<int> callIntInt(JITTargetAddress Addr, int Arg) {
LLVM_DEBUG(dbgs() << "Calling int(*)(int) " << format("0x%016" PRIx64, Addr)
<< "\n");
return callB<exec::CallIntInt>(Addr, Arg);
}
/// Call the int(int, char*[]) function at the given address in the target and
/// return its result.
Expected<int> callMain(JITTargetAddress Addr,
const std::vector<std::string> &Args) {
LLVM_DEBUG(dbgs() << "Calling int(*)(int, char*[]) "
<< format("0x%016" PRIx64, Addr) << "\n");
return callB<exec::CallMain>(Addr, Args);
}
/// Call the void() function at the given address in the target and wait for
/// it to finish.
Error callVoidVoid(JITTargetAddress Addr) {
LLVM_DEBUG(dbgs() << "Calling void(*)(void) "
<< format("0x%016" PRIx64, Addr) << "\n");
return callB<exec::CallVoidVoid>(Addr);
}
/// Create an RCMemoryManager which will allocate its memory on the remote
/// target.
Expected<std::unique_ptr<RemoteRTDyldMemoryManager>>
createRemoteMemoryManager() {
auto Id = AllocatorIds.getNext();
if (auto Err = callB<mem::CreateRemoteAllocator>(Id))
return std::move(Err);
return std::unique_ptr<RemoteRTDyldMemoryManager>(
new RemoteRTDyldMemoryManager(*this, Id));
}
/// Create a JITLink-compatible memory manager which will allocate working
/// memory on the host and target memory on the remote target.
Expected<std::unique_ptr<RemoteJITLinkMemoryManager>>
createRemoteJITLinkMemoryManager() {
auto Id = AllocatorIds.getNext();
if (auto Err = callB<mem::CreateRemoteAllocator>(Id))
return std::move(Err);
LLVM_DEBUG(dbgs() << "Created remote allocator " << Id << "\n");
return std::unique_ptr<RemoteJITLinkMemoryManager>(
new RemoteJITLinkMemoryManager(*this, Id));
}
/// Create an RCIndirectStubsManager that will allocate stubs on the remote
/// target.
Expected<std::unique_ptr<RemoteIndirectStubsManager>>
createIndirectStubsManager() {
auto Id = IndirectStubOwnerIds.getNext();
if (auto Err = callB<stubs::CreateIndirectStubsOwner>(Id))
return std::move(Err);
return std::make_unique<RemoteIndirectStubsManager>(*this, Id);
}
Expected<RemoteCompileCallbackManager &>
enableCompileCallbacks(JITTargetAddress ErrorHandlerAddress) {
assert(!CallbackManager && "CallbackManager already obtained");
// Emit the resolver block on the JIT server.
if (auto Err = callB<stubs::EmitResolverBlock>())
return std::move(Err);
// Create the callback manager.
CallbackManager.emplace(*this, ES, ErrorHandlerAddress);
RemoteCompileCallbackManager &Mgr = *CallbackManager;
return Mgr;
}
/// 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.
Expected<JITTargetAddress> getSymbolAddress(StringRef Name) {
return callB<utils::GetSymbolAddress>(Name);
}
/// Get the triple for the remote target.
const std::string &getTargetTriple() const { return RemoteTargetTriple; }
Error terminateSession() { return callB<utils::TerminateSession>(); }
private:
OrcRemoteTargetClient(shared::RawByteChannel &Channel, ExecutionSession &ES,
Error &Err)
: shared::SingleThreadedRPCEndpoint<shared::RawByteChannel>(Channel,
true),
ES(ES) {
ErrorAsOutParameter EAO(&Err);
addHandler<utils::RequestCompile>(
[this](JITTargetAddress Addr) -> JITTargetAddress {
if (CallbackManager)
return CallbackManager->executeCompileCallback(Addr);
return 0;
});
if (auto RIOrErr = callB<utils::GetRemoteInfo>()) {
std::tie(RemoteTargetTriple, RemotePointerSize, RemotePageSize,
RemoteTrampolineSize, RemoteIndirectStubSize) = *RIOrErr;
Err = Error::success();
} else
Err = RIOrErr.takeError();
}
void deregisterEHFrames(JITTargetAddress Addr, uint32_t Size) {
if (auto Err = callB<eh::RegisterEHFrames>(Addr, Size))
ES.reportError(std::move(Err));
}
void destroyRemoteAllocator(ResourceIdMgr::ResourceId Id) {
if (auto Err = callB<mem::DestroyRemoteAllocator>(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);
}
}
void destroyIndirectStubsManager(ResourceIdMgr::ResourceId Id) {
IndirectStubOwnerIds.release(Id);
if (auto Err = callB<stubs::DestroyIndirectStubsOwner>(Id))
ES.reportError(std::move(Err));
}
Expected<std::tuple<JITTargetAddress, JITTargetAddress, uint32_t>>
emitIndirectStubs(ResourceIdMgr::ResourceId Id, uint32_t NumStubsRequired) {
return callB<stubs::EmitIndirectStubs>(Id, NumStubsRequired);
}
Expected<std::tuple<JITTargetAddress, uint32_t>> emitTrampolineBlock() {
return callB<stubs::EmitTrampolineBlock>();
}
uint32_t getIndirectStubSize() const { return RemoteIndirectStubSize; }
uint32_t getPageSize() const { return RemotePageSize; }
uint32_t getPointerSize() const { return RemotePointerSize; }
uint32_t getTrampolineSize() const { return RemoteTrampolineSize; }
Expected<std::vector<uint8_t>> readMem(char *Dst, JITTargetAddress Src,
uint64_t Size) {
return callB<mem::ReadMem>(Src, Size);
}
Error registerEHFrames(JITTargetAddress &RAddr, uint32_t Size) {
// FIXME: Duplicate error and report it via ReportError too?
return callB<eh::RegisterEHFrames>(RAddr, Size);
}
JITTargetAddress reserveMem(ResourceIdMgr::ResourceId Id, uint64_t Size,
uint32_t Align) {
if (auto AddrOrErr = callB<mem::ReserveMem>(Id, Size, Align))
return *AddrOrErr;
else {
ES.reportError(AddrOrErr.takeError());
return 0;
}
}
bool setProtections(ResourceIdMgr::ResourceId Id,
JITTargetAddress RemoteSegAddr, unsigned ProtFlags) {
if (auto Err = callB<mem::SetProtections>(Id, RemoteSegAddr, ProtFlags)) {
ES.reportError(std::move(Err));
return true;
} else
return false;
}
bool writeMem(JITTargetAddress Addr, const char *Src, uint64_t Size) {
if (auto Err = callB<mem::WriteMem>(DirectBufferWriter(Src, Addr, Size))) {
ES.reportError(std::move(Err));
return true;
} else
return false;
}
Error writePointer(JITTargetAddress Addr, JITTargetAddress PtrVal) {
return callB<mem::WritePtr>(Addr, PtrVal);
}
static Error doNothing() { return Error::success(); }
ExecutionSession &ES;
std::function<void(Error)> ReportError;
std::string RemoteTargetTriple;
uint32_t RemotePointerSize = 0;
uint32_t RemotePageSize = 0;
uint32_t RemoteTrampolineSize = 0;
uint32_t RemoteIndirectStubSize = 0;
ResourceIdMgr AllocatorIds, IndirectStubOwnerIds;
Optional<RemoteCompileCallbackManager> CallbackManager;
};
} // end namespace remote
} // end namespace orc
} // end namespace llvm
#undef DEBUG_TYPE
#endif // LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETCLIENT_H