[llvm] f406851 - [ORC] Remote OrcRemoteTargetClient and OrcRemoteTargetServer.
Lang Hames via llvm-commits
llvm-commits at lists.llvm.org
Sun Sep 26 11:35:36 PDT 2021
Author: Lang Hames
Date: 2021-09-26T11:32:51-07:00
New Revision: f40685138ba182fc823f569f6d88b7d3ddf34b9e
URL: https://github.com/llvm/llvm-project/commit/f40685138ba182fc823f569f6d88b7d3ddf34b9e
DIFF: https://github.com/llvm/llvm-project/commit/f40685138ba182fc823f569f6d88b7d3ddf34b9e.diff
LOG: [ORC] Remote OrcRemoteTargetClient and OrcRemoteTargetServer.
Now that the lli and lli-child-target tools have been updated to use
SimpleRemoteEPC (6498b0e991b) the OrcRemoteTarget* APIs are no longer needed.
Once the LLJITWithRemoteDebugging example has been migrated to SimpleRemoteEPC
we will remove OrcRPCExecutorProcessControl, and the ORC RPC system itself.
Added:
Modified:
Removed:
llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
################################################################################
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h b/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
deleted file mode 100644
index 3d139740d677..000000000000
--- a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
+++ /dev/null
@@ -1,925 +0,0 @@
-//===- 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
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h b/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
deleted file mode 100644
index 367bfb369191..000000000000
--- a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
+++ /dev/null
@@ -1,386 +0,0 @@
-//===- OrcRemoteTargetRPCAPI.h - Orc Remote-target RPC API ------*- 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 Orc remote-target RPC API. It should not be used
-// directly, but is used by the RemoteTargetClient and RemoteTargetServer
-// classes.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETRPCAPI_H
-#define LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETRPCAPI_H
-
-#include "llvm/ExecutionEngine/JITSymbol.h"
-#include "llvm/ExecutionEngine/Orc/Shared/RPCUtils.h"
-#include "llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h"
-
-namespace llvm {
-namespace orc {
-
-namespace remote {
-
-/// Template error for missing resources.
-template <typename ResourceIdT>
-class ResourceNotFound
- : public ErrorInfo<ResourceNotFound<ResourceIdT>> {
-public:
- static char ID;
-
- ResourceNotFound(ResourceIdT ResourceId,
- std::string ResourceDescription = "")
- : ResourceId(std::move(ResourceId)),
- ResourceDescription(std::move(ResourceDescription)) {}
-
- std::error_code convertToErrorCode() const override {
- return orcError(OrcErrorCode::UnknownResourceHandle);
- }
-
- void log(raw_ostream &OS) const override {
- OS << (ResourceDescription.empty()
- ? "Remote resource with id "
- : ResourceDescription)
- << " " << ResourceId << " not found";
- }
-
-private:
- ResourceIdT ResourceId;
- std::string ResourceDescription;
-};
-
-template <typename ResourceIdT>
-char ResourceNotFound<ResourceIdT>::ID = 0;
-
-class DirectBufferWriter {
-public:
- DirectBufferWriter() = default;
- DirectBufferWriter(const char *Src, JITTargetAddress Dst, uint64_t Size)
- : Src(Src), Dst(Dst), Size(Size) {}
-
- const char *getSrc() const { return Src; }
- JITTargetAddress getDst() const { return Dst; }
- uint64_t getSize() const { return Size; }
-
-private:
- const char *Src;
- JITTargetAddress Dst;
- uint64_t Size;
-};
-
-} // end namespace remote
-
-namespace shared {
-
-template <> class SerializationTypeName<JITSymbolFlags> {
-public:
- static const char *getName() { return "JITSymbolFlags"; }
-};
-
-template <typename ChannelT>
-class SerializationTraits<ChannelT, JITSymbolFlags> {
-public:
-
- static Error serialize(ChannelT &C, const JITSymbolFlags &Flags) {
- return serializeSeq(C, Flags.getRawFlagsValue(), Flags.getTargetFlags());
- }
-
- static Error deserialize(ChannelT &C, JITSymbolFlags &Flags) {
- JITSymbolFlags::UnderlyingType JITFlags;
- JITSymbolFlags::TargetFlagsType TargetFlags;
- if (auto Err = deserializeSeq(C, JITFlags, TargetFlags))
- return Err;
- Flags = JITSymbolFlags(static_cast<JITSymbolFlags::FlagNames>(JITFlags),
- TargetFlags);
- return Error::success();
- }
-};
-
-template <> class SerializationTypeName<remote::DirectBufferWriter> {
-public:
- static const char *getName() { return "DirectBufferWriter"; }
-};
-
-template <typename ChannelT>
-class SerializationTraits<
- ChannelT, remote::DirectBufferWriter, remote::DirectBufferWriter,
- std::enable_if_t<std::is_base_of<RawByteChannel, ChannelT>::value>> {
-public:
- static Error serialize(ChannelT &C, const remote::DirectBufferWriter &DBW) {
- if (auto EC = serializeSeq(C, DBW.getDst()))
- return EC;
- if (auto EC = serializeSeq(C, DBW.getSize()))
- return EC;
- return C.appendBytes(DBW.getSrc(), DBW.getSize());
- }
-
- static Error deserialize(ChannelT &C, remote::DirectBufferWriter &DBW) {
- JITTargetAddress Dst;
- if (auto EC = deserializeSeq(C, Dst))
- return EC;
- uint64_t Size;
- if (auto EC = deserializeSeq(C, Size))
- return EC;
- char *Addr = reinterpret_cast<char *>(static_cast<uintptr_t>(Dst));
-
- DBW = remote::DirectBufferWriter(nullptr, Dst, Size);
-
- return C.readBytes(Addr, Size);
- }
-};
-
-} // end namespace shared
-
-namespace remote {
-
-class ResourceIdMgr {
-public:
- using ResourceId = uint64_t;
- static const ResourceId InvalidId = ~0U;
-
- ResourceIdMgr() = default;
- explicit ResourceIdMgr(ResourceId FirstValidId)
- : NextId(std::move(FirstValidId)) {}
-
- ResourceId getNext() {
- if (!FreeIds.empty()) {
- ResourceId I = FreeIds.back();
- FreeIds.pop_back();
- return I;
- }
- assert(NextId + 1 != ~0ULL && "All ids allocated");
- return NextId++;
- }
-
- void release(ResourceId I) { FreeIds.push_back(I); }
-
-private:
- ResourceId NextId = 1;
- std::vector<ResourceId> FreeIds;
-};
-
-/// Registers EH frames on the remote.
-namespace eh {
-
- /// Registers EH frames on the remote.
-class RegisterEHFrames
- : public shared::RPCFunction<RegisterEHFrames,
- void(JITTargetAddress Addr, uint32_t Size)> {
-public:
- static const char *getName() { return "RegisterEHFrames"; }
-};
-
- /// Deregisters EH frames on the remote.
-class DeregisterEHFrames
- : public shared::RPCFunction<DeregisterEHFrames,
- void(JITTargetAddress Addr, uint32_t Size)> {
-public:
- static const char *getName() { return "DeregisterEHFrames"; }
-};
-
-} // end namespace eh
-
-/// RPC functions for executing remote code.
-namespace exec {
-
- /// Call an 'int32_t()'-type function on the remote, returns the called
- /// function's return value.
-class CallIntVoid
- : public shared::RPCFunction<CallIntVoid, int32_t(JITTargetAddress Addr)> {
-public:
- static const char *getName() { return "CallIntVoid"; }
-};
-
- /// Call an 'int32_t(int32_t)'-type function on the remote, returns the called
- /// function's return value.
-class CallIntInt
- : public shared::RPCFunction<CallIntInt,
- int32_t(JITTargetAddress Addr, int)> {
-public:
- static const char *getName() { return "CallIntInt"; }
-};
-
- /// Call an 'int32_t(int32_t, char**)'-type function on the remote, returns the
- /// called function's return value.
-class CallMain
- : public shared::RPCFunction<CallMain,
- int32_t(JITTargetAddress Addr,
- std::vector<std::string> Args)> {
-public:
- static const char *getName() { return "CallMain"; }
-};
-
- /// Calls a 'void()'-type function on the remote, returns when the called
- /// function completes.
-class CallVoidVoid
- : public shared::RPCFunction<CallVoidVoid, void(JITTargetAddress FnAddr)> {
-public:
- static const char *getName() { return "CallVoidVoid"; }
-};
-
-} // end namespace exec
-
-/// RPC functions for remote memory management / inspection / modification.
-namespace mem {
-
- /// Creates a memory allocator on the remote.
-class CreateRemoteAllocator
- : public shared::RPCFunction<CreateRemoteAllocator,
- void(ResourceIdMgr::ResourceId AllocatorID)> {
-public:
- static const char *getName() { return "CreateRemoteAllocator"; }
-};
-
- /// Destroys a remote allocator, freeing any memory allocated by it.
-class DestroyRemoteAllocator
- : public shared::RPCFunction<DestroyRemoteAllocator,
- void(ResourceIdMgr::ResourceId AllocatorID)> {
-public:
- static const char *getName() { return "DestroyRemoteAllocator"; }
-};
-
- /// Read a remote memory block.
-class ReadMem
- : public shared::RPCFunction<
- ReadMem, std::vector<uint8_t>(JITTargetAddress Src, uint64_t Size)> {
-public:
- static const char *getName() { return "ReadMem"; }
-};
-
- /// Reserve a block of memory on the remote via the given allocator.
-class ReserveMem
- : public shared::RPCFunction<
- ReserveMem, JITTargetAddress(ResourceIdMgr::ResourceId AllocID,
- uint64_t Size, uint32_t Align)> {
-public:
- static const char *getName() { return "ReserveMem"; }
-};
-
- /// Set the memory protection on a memory block.
-class SetProtections
- : public shared::RPCFunction<
- SetProtections, void(ResourceIdMgr::ResourceId AllocID,
- JITTargetAddress Dst, uint32_t ProtFlags)> {
-public:
- static const char *getName() { return "SetProtections"; }
-};
-
- /// Write to a remote memory block.
-class WriteMem
- : public shared::RPCFunction<WriteMem,
- void(remote::DirectBufferWriter DB)> {
-public:
- static const char *getName() { return "WriteMem"; }
-};
-
- /// Write to a remote pointer.
-class WritePtr
- : public shared::RPCFunction<WritePtr, void(JITTargetAddress Dst,
- JITTargetAddress Val)> {
-public:
- static const char *getName() { return "WritePtr"; }
-};
-
-} // end namespace mem
-
-/// RPC functions for remote stub and trampoline management.
-namespace stubs {
-
- /// Creates an indirect stub owner on the remote.
-class CreateIndirectStubsOwner
- : public shared::RPCFunction<CreateIndirectStubsOwner,
- void(ResourceIdMgr::ResourceId StubOwnerID)> {
-public:
- static const char *getName() { return "CreateIndirectStubsOwner"; }
-};
-
- /// RPC function for destroying an indirect stubs owner.
-class DestroyIndirectStubsOwner
- : public shared::RPCFunction<DestroyIndirectStubsOwner,
- void(ResourceIdMgr::ResourceId StubsOwnerID)> {
-public:
- static const char *getName() { return "DestroyIndirectStubsOwner"; }
-};
-
- /// EmitIndirectStubs result is (StubsBase, PtrsBase, NumStubsEmitted).
-class EmitIndirectStubs
- : public shared::RPCFunction<
- EmitIndirectStubs,
- std::tuple<JITTargetAddress, JITTargetAddress, uint32_t>(
- ResourceIdMgr::ResourceId StubsOwnerID,
- uint32_t NumStubsRequired)> {
-public:
- static const char *getName() { return "EmitIndirectStubs"; }
-};
-
- /// RPC function to emit the resolver block and return its address.
-class EmitResolverBlock
- : public shared::RPCFunction<EmitResolverBlock, void()> {
-public:
- static const char *getName() { return "EmitResolverBlock"; }
-};
-
- /// EmitTrampolineBlock result is (BlockAddr, NumTrampolines).
-class EmitTrampolineBlock
- : public shared::RPCFunction<EmitTrampolineBlock,
- std::tuple<JITTargetAddress, uint32_t>()> {
-public:
- static const char *getName() { return "EmitTrampolineBlock"; }
-};
-
-} // end namespace stubs
-
-/// Miscelaneous RPC functions for dealing with remotes.
-namespace utils {
-
- /// GetRemoteInfo result is (Triple, PointerSize, PageSize, TrampolineSize,
- /// IndirectStubsSize).
-class GetRemoteInfo
- : public shared::RPCFunction<
- GetRemoteInfo,
- std::tuple<std::string, uint32_t, uint32_t, uint32_t, uint32_t>()> {
-public:
- static const char *getName() { return "GetRemoteInfo"; }
-};
-
- /// Get the address of a remote symbol.
-class GetSymbolAddress
- : public shared::RPCFunction<GetSymbolAddress,
- JITTargetAddress(std::string SymbolName)> {
-public:
- static const char *getName() { return "GetSymbolAddress"; }
-};
-
- /// Request that the host execute a compile callback.
-class RequestCompile
- : public shared::RPCFunction<
- RequestCompile, JITTargetAddress(JITTargetAddress TrampolineAddr)> {
-public:
- static const char *getName() { return "RequestCompile"; }
-};
-
- /// Notify the remote and terminate the session.
-class TerminateSession : public shared::RPCFunction<TerminateSession, void()> {
-public:
- static const char *getName() { return "TerminateSession"; }
-};
-
-} // namespace utils
-
-class OrcRemoteTargetRPCAPI
- : public shared::SingleThreadedRPCEndpoint<shared::RawByteChannel> {
-public:
- // FIXME: Remove constructors once MSVC supports synthesizing move-ops.
- OrcRemoteTargetRPCAPI(shared::RawByteChannel &C)
- : shared::SingleThreadedRPCEndpoint<shared::RawByteChannel>(C, true) {}
-};
-
-} // end namespace remote
-
-} // end namespace orc
-} // end namespace llvm
-
-#endif // LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETRPCAPI_H
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h b/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
deleted file mode 100644
index ce9bf064303d..000000000000
--- a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
+++ /dev/null
@@ -1,464 +0,0 @@
-//===- OrcRemoteTargetServer.h - Orc Remote-target Server -------*- 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 OrcRemoteTargetServer class. It can be used to build a
-// JIT server that can execute code sent from an OrcRemoteTargetClient.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETSERVER_H
-#define LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETSERVER_H
-
-#include "llvm/ExecutionEngine/JITSymbol.h"
-#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
-#include "llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h"
-#include "llvm/ExecutionEngine/Orc/Shared/OrcError.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/Format.h"
-#include "llvm/Support/Host.h"
-#include "llvm/Support/Memory.h"
-#include "llvm/Support/Process.h"
-#include "llvm/Support/raw_ostream.h"
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <map>
-#include <memory>
-#include <string>
-#include <system_error>
-#include <tuple>
-#include <type_traits>
-#include <vector>
-
-#define DEBUG_TYPE "orc-remote"
-
-namespace llvm {
-namespace orc {
-namespace remote {
-
-template <typename ChannelT, typename TargetT>
-class OrcRemoteTargetServer
- : public shared::SingleThreadedRPCEndpoint<shared::RawByteChannel> {
-public:
- using SymbolLookupFtor =
- std::function<JITTargetAddress(const std::string &Name)>;
-
- using EHFrameRegistrationFtor =
- std::function<void(uint8_t *Addr, uint32_t Size)>;
-
- OrcRemoteTargetServer(ChannelT &Channel, SymbolLookupFtor SymbolLookup,
- EHFrameRegistrationFtor EHFramesRegister,
- EHFrameRegistrationFtor EHFramesDeregister)
- : shared::SingleThreadedRPCEndpoint<shared::RawByteChannel>(Channel,
- true),
- SymbolLookup(std::move(SymbolLookup)),
- EHFramesRegister(std::move(EHFramesRegister)),
- EHFramesDeregister(std::move(EHFramesDeregister)) {
- using ThisT = std::remove_reference_t<decltype(*this)>;
- addHandler<exec::CallIntVoid>(*this, &ThisT::handleCallIntVoid);
- addHandler<exec::CallIntInt>(*this, &ThisT::handleCallIntInt);
- addHandler<exec::CallMain>(*this, &ThisT::handleCallMain);
- addHandler<exec::CallVoidVoid>(*this, &ThisT::handleCallVoidVoid);
- addHandler<mem::CreateRemoteAllocator>(*this,
- &ThisT::handleCreateRemoteAllocator);
- addHandler<mem::DestroyRemoteAllocator>(
- *this, &ThisT::handleDestroyRemoteAllocator);
- addHandler<mem::ReadMem>(*this, &ThisT::handleReadMem);
- addHandler<mem::ReserveMem>(*this, &ThisT::handleReserveMem);
- addHandler<mem::SetProtections>(*this, &ThisT::handleSetProtections);
- addHandler<mem::WriteMem>(*this, &ThisT::handleWriteMem);
- addHandler<mem::WritePtr>(*this, &ThisT::handleWritePtr);
- addHandler<eh::RegisterEHFrames>(*this, &ThisT::handleRegisterEHFrames);
- addHandler<eh::DeregisterEHFrames>(*this, &ThisT::handleDeregisterEHFrames);
- addHandler<stubs::CreateIndirectStubsOwner>(
- *this, &ThisT::handleCreateIndirectStubsOwner);
- addHandler<stubs::DestroyIndirectStubsOwner>(
- *this, &ThisT::handleDestroyIndirectStubsOwner);
- addHandler<stubs::EmitIndirectStubs>(*this,
- &ThisT::handleEmitIndirectStubs);
- addHandler<stubs::EmitResolverBlock>(*this,
- &ThisT::handleEmitResolverBlock);
- addHandler<stubs::EmitTrampolineBlock>(*this,
- &ThisT::handleEmitTrampolineBlock);
- addHandler<utils::GetSymbolAddress>(*this, &ThisT::handleGetSymbolAddress);
- addHandler<utils::GetRemoteInfo>(*this, &ThisT::handleGetRemoteInfo);
- addHandler<utils::TerminateSession>(*this, &ThisT::handleTerminateSession);
- }
-
- // FIXME: Remove move/copy ops once MSVC supports synthesizing move ops.
- OrcRemoteTargetServer(const OrcRemoteTargetServer &) = delete;
- OrcRemoteTargetServer &operator=(const OrcRemoteTargetServer &) = delete;
-
- OrcRemoteTargetServer(OrcRemoteTargetServer &&Other) = default;
- OrcRemoteTargetServer &operator=(OrcRemoteTargetServer &&) = delete;
-
- Expected<JITTargetAddress> requestCompile(JITTargetAddress TrampolineAddr) {
- return callB<utils::RequestCompile>(TrampolineAddr);
- }
-
- bool receivedTerminate() const { return TerminateFlag; }
-
-private:
- struct Allocator {
- Allocator() = default;
- Allocator(Allocator &&Other) : Allocs(std::move(Other.Allocs)) {}
-
- Allocator &operator=(Allocator &&Other) {
- Allocs = std::move(Other.Allocs);
- return *this;
- }
-
- ~Allocator() {
- for (auto &Alloc : Allocs)
- sys::Memory::releaseMappedMemory(Alloc.second);
- }
-
- Error allocate(void *&Addr, size_t Size, uint32_t Align) {
- std::error_code EC;
- sys::MemoryBlock MB = sys::Memory::allocateMappedMemory(
- Size, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);
- if (EC)
- return errorCodeToError(EC);
-
- Addr = MB.base();
- assert(Allocs.find(MB.base()) == Allocs.end() && "Duplicate alloc");
- Allocs[MB.base()] = std::move(MB);
- return Error::success();
- }
-
- Error setProtections(void *block, unsigned Flags) {
- auto I = Allocs.find(block);
- if (I == Allocs.end())
- return errorCodeToError(orcError(OrcErrorCode::RemoteMProtectAddrUnrecognized));
- return errorCodeToError(
- sys::Memory::protectMappedMemory(I->second, Flags));
- }
-
- private:
- std::map<void *, sys::MemoryBlock> Allocs;
- };
-
- static Error doNothing() { return Error::success(); }
-
- static JITTargetAddress reenter(void *JITTargetAddr, void *TrampolineAddr) {
- auto T = static_cast<OrcRemoteTargetServer *>(JITTargetAddr);
- auto AddrOrErr = T->requestCompile(static_cast<JITTargetAddress>(
- reinterpret_cast<uintptr_t>(TrampolineAddr)));
- // FIXME: Allow customizable failure substitution functions.
- assert(AddrOrErr && "Compile request failed");
- return *AddrOrErr;
- }
-
- Expected<int32_t> handleCallIntVoid(JITTargetAddress Addr) {
- using IntVoidFnTy = int (*)();
-
- IntVoidFnTy Fn =
- reinterpret_cast<IntVoidFnTy>(static_cast<uintptr_t>(Addr));
-
- LLVM_DEBUG(dbgs() << " Calling " << format("0x%016x", Addr) << "\n");
- int Result = Fn();
- LLVM_DEBUG(dbgs() << " Result = " << Result << "\n");
-
- return Result;
- }
-
- Expected<int32_t> handleCallIntInt(JITTargetAddress Addr, int Arg) {
- using IntIntFnTy = int (*)(int);
-
- IntIntFnTy Fn = reinterpret_cast<IntIntFnTy>(static_cast<uintptr_t>(Addr));
-
- LLVM_DEBUG(dbgs() << " Calling " << format("0x%016x", Addr)
- << " with argument " << Arg << "\n");
- int Result = Fn(Arg);
- LLVM_DEBUG(dbgs() << " Result = " << Result << "\n");
-
- return Result;
- }
-
- Expected<int32_t> handleCallMain(JITTargetAddress Addr,
- std::vector<std::string> Args) {
- using MainFnTy = int (*)(int, const char *[]);
-
- MainFnTy Fn = reinterpret_cast<MainFnTy>(static_cast<uintptr_t>(Addr));
- int ArgC = Args.size() + 1;
- int Idx = 1;
- std::unique_ptr<const char *[]> ArgV(new const char *[ArgC + 1]);
- ArgV[0] = "<jit process>";
- for (auto &Arg : Args)
- ArgV[Idx++] = Arg.c_str();
- ArgV[ArgC] = 0;
- LLVM_DEBUG(for (int Idx = 0; Idx < ArgC; ++Idx) {
- llvm::dbgs() << "Arg " << Idx << ": " << ArgV[Idx] << "\n";
- });
-
- LLVM_DEBUG(dbgs() << " Calling " << format("0x%016x", Addr) << "\n");
- int Result = Fn(ArgC, ArgV.get());
- LLVM_DEBUG(dbgs() << " Result = " << Result << "\n");
-
- return Result;
- }
-
- Error handleCallVoidVoid(JITTargetAddress Addr) {
- using VoidVoidFnTy = void (*)();
-
- VoidVoidFnTy Fn =
- reinterpret_cast<VoidVoidFnTy>(static_cast<uintptr_t>(Addr));
-
- LLVM_DEBUG(dbgs() << " Calling " << format("0x%016x", Addr) << "\n");
- Fn();
- LLVM_DEBUG(dbgs() << " Complete.\n");
-
- return Error::success();
- }
-
- Error handleCreateRemoteAllocator(ResourceIdMgr::ResourceId Id) {
- auto I = Allocators.find(Id);
- if (I != Allocators.end())
- return errorCodeToError(
- orcError(OrcErrorCode::RemoteAllocatorIdAlreadyInUse));
- LLVM_DEBUG(dbgs() << " Created allocator " << Id << "\n");
- Allocators[Id] = Allocator();
- return Error::success();
- }
-
- Error handleCreateIndirectStubsOwner(ResourceIdMgr::ResourceId Id) {
- auto I = IndirectStubsOwners.find(Id);
- if (I != IndirectStubsOwners.end())
- return errorCodeToError(
- orcError(OrcErrorCode::RemoteIndirectStubsOwnerIdAlreadyInUse));
- LLVM_DEBUG(dbgs() << " Create indirect stubs owner " << Id << "\n");
- IndirectStubsOwners[Id] = ISBlockOwnerList();
- return Error::success();
- }
-
- Error handleDeregisterEHFrames(JITTargetAddress TAddr, uint32_t Size) {
- uint8_t *Addr = reinterpret_cast<uint8_t *>(static_cast<uintptr_t>(TAddr));
- LLVM_DEBUG(dbgs() << " Registering EH frames at "
- << format("0x%016x", TAddr) << ", Size = " << Size
- << " bytes\n");
- EHFramesDeregister(Addr, Size);
- return Error::success();
- }
-
- Error handleDestroyRemoteAllocator(ResourceIdMgr::ResourceId Id) {
- auto I = Allocators.find(Id);
- if (I == Allocators.end())
- return errorCodeToError(
- orcError(OrcErrorCode::RemoteAllocatorDoesNotExist));
- Allocators.erase(I);
- LLVM_DEBUG(dbgs() << " Destroyed allocator " << Id << "\n");
- return Error::success();
- }
-
- Error handleDestroyIndirectStubsOwner(ResourceIdMgr::ResourceId Id) {
- auto I = IndirectStubsOwners.find(Id);
- if (I == IndirectStubsOwners.end())
- return errorCodeToError(
- orcError(OrcErrorCode::RemoteIndirectStubsOwnerDoesNotExist));
- IndirectStubsOwners.erase(I);
- return Error::success();
- }
-
- Expected<std::tuple<JITTargetAddress, JITTargetAddress, uint32_t>>
- handleEmitIndirectStubs(ResourceIdMgr::ResourceId Id,
- uint32_t NumStubsRequired) {
- LLVM_DEBUG(dbgs() << " ISMgr " << Id << " request " << NumStubsRequired
- << " stubs.\n");
-
- auto StubOwnerItr = IndirectStubsOwners.find(Id);
- if (StubOwnerItr == IndirectStubsOwners.end())
- return errorCodeToError(
- orcError(OrcErrorCode::RemoteIndirectStubsOwnerDoesNotExist));
-
- auto IS = LocalIndirectStubsInfo<TargetT>::create(
- NumStubsRequired, sys::Process::getPageSizeEstimate());
- if (!IS)
- return IS.takeError();
-
- JITTargetAddress StubsBase = pointerToJITTargetAddress(IS->getStub(0));
- JITTargetAddress PtrsBase = pointerToJITTargetAddress(IS->getPtr(0));
- uint32_t NumStubsEmitted = IS->getNumStubs();
-
- auto &BlockList = StubOwnerItr->second;
- BlockList.push_back(std::move(*IS));
-
- return std::make_tuple(StubsBase, PtrsBase, NumStubsEmitted);
- }
-
- Error handleEmitResolverBlock() {
- std::error_code EC;
- ResolverBlock = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
- TargetT::ResolverCodeSize, nullptr,
- sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
- if (EC)
- return errorCodeToError(EC);
-
- TargetT::writeResolverCode(static_cast<char *>(ResolverBlock.base()),
- pointerToJITTargetAddress(ResolverBlock.base()),
- pointerToJITTargetAddress(&reenter),
- pointerToJITTargetAddress(this));
-
- return errorCodeToError(sys::Memory::protectMappedMemory(
- ResolverBlock.getMemoryBlock(),
- sys::Memory::MF_READ | sys::Memory::MF_EXEC));
- }
-
- Expected<std::tuple<JITTargetAddress, uint32_t>> handleEmitTrampolineBlock() {
- std::error_code EC;
- auto TrampolineBlock =
- sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
- sys::Process::getPageSizeEstimate(), nullptr,
- sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
- if (EC)
- return errorCodeToError(EC);
-
- uint32_t NumTrampolines =
- (sys::Process::getPageSizeEstimate() - TargetT::PointerSize) /
- TargetT::TrampolineSize;
-
- char *TrampolineMem = static_cast<char *>(TrampolineBlock.base());
- TargetT::writeTrampolines(
- TrampolineMem, pointerToJITTargetAddress(TrampolineMem),
- pointerToJITTargetAddress(ResolverBlock.base()), NumTrampolines);
-
- EC = sys::Memory::protectMappedMemory(TrampolineBlock.getMemoryBlock(),
- sys::Memory::MF_READ |
- sys::Memory::MF_EXEC);
-
- TrampolineBlocks.push_back(std::move(TrampolineBlock));
-
- return std::make_tuple(pointerToJITTargetAddress(TrampolineMem),
- NumTrampolines);
- }
-
- Expected<JITTargetAddress> handleGetSymbolAddress(const std::string &Name) {
- JITTargetAddress Addr = SymbolLookup(Name);
- LLVM_DEBUG(dbgs() << " Symbol '" << Name
- << "' = " << format("0x%016x", Addr) << "\n");
- return Addr;
- }
-
- Expected<std::tuple<std::string, uint32_t, uint32_t, uint32_t, uint32_t>>
- handleGetRemoteInfo() {
- std::string ProcessTriple = sys::getProcessTriple();
- uint32_t PointerSize = TargetT::PointerSize;
- uint32_t PageSize = sys::Process::getPageSizeEstimate();
- uint32_t TrampolineSize = TargetT::TrampolineSize;
- uint32_t IndirectStubSize = TargetT::StubSize;
- LLVM_DEBUG(dbgs() << " Remote info:\n"
- << " triple = '" << ProcessTriple << "'\n"
- << " pointer size = " << PointerSize << "\n"
- << " page size = " << PageSize << "\n"
- << " trampoline size = " << TrampolineSize << "\n"
- << " indirect stub size = " << IndirectStubSize
- << "\n");
- return std::make_tuple(ProcessTriple, PointerSize, PageSize, TrampolineSize,
- IndirectStubSize);
- }
-
- Expected<std::vector<uint8_t>> handleReadMem(JITTargetAddress RSrc,
- uint64_t Size) {
- uint8_t *Src = reinterpret_cast<uint8_t *>(static_cast<uintptr_t>(RSrc));
-
- LLVM_DEBUG(dbgs() << " Reading " << Size << " bytes from "
- << format("0x%016x", RSrc) << "\n");
-
- std::vector<uint8_t> Buffer;
- Buffer.resize(Size);
- for (uint8_t *P = Src; Size != 0; --Size)
- Buffer.push_back(*P++);
-
- return Buffer;
- }
-
- Error handleRegisterEHFrames(JITTargetAddress TAddr, uint32_t Size) {
- uint8_t *Addr = reinterpret_cast<uint8_t *>(static_cast<uintptr_t>(TAddr));
- LLVM_DEBUG(dbgs() << " Registering EH frames at "
- << format("0x%016x", TAddr) << ", Size = " << Size
- << " bytes\n");
- EHFramesRegister(Addr, Size);
- return Error::success();
- }
-
- Expected<JITTargetAddress> handleReserveMem(ResourceIdMgr::ResourceId Id,
- uint64_t Size, uint32_t Align) {
- auto I = Allocators.find(Id);
- if (I == Allocators.end())
- return errorCodeToError(
- orcError(OrcErrorCode::RemoteAllocatorDoesNotExist));
- auto &Allocator = I->second;
- void *LocalAllocAddr = nullptr;
- if (auto Err = Allocator.allocate(LocalAllocAddr, Size, Align))
- return std::move(Err);
-
- LLVM_DEBUG(dbgs() << " Allocator " << Id << " reserved " << LocalAllocAddr
- << " (" << Size << " bytes, alignment " << Align
- << ")\n");
-
- JITTargetAddress AllocAddr = static_cast<JITTargetAddress>(
- reinterpret_cast<uintptr_t>(LocalAllocAddr));
-
- return AllocAddr;
- }
-
- Error handleSetProtections(ResourceIdMgr::ResourceId Id,
- JITTargetAddress Addr, uint32_t Flags) {
- auto I = Allocators.find(Id);
- if (I == Allocators.end())
- return errorCodeToError(
- orcError(OrcErrorCode::RemoteAllocatorDoesNotExist));
- auto &Allocator = I->second;
- void *LocalAddr = reinterpret_cast<void *>(static_cast<uintptr_t>(Addr));
- LLVM_DEBUG(dbgs() << " Allocator " << Id << " set permissions on "
- << LocalAddr << " to "
- << (Flags & sys::Memory::MF_READ ? 'R' : '-')
- << (Flags & sys::Memory::MF_WRITE ? 'W' : '-')
- << (Flags & sys::Memory::MF_EXEC ? 'X' : '-') << "\n");
- return Allocator.setProtections(LocalAddr, Flags);
- }
-
- Error handleTerminateSession() {
- TerminateFlag = true;
- return Error::success();
- }
-
- Error handleWriteMem(DirectBufferWriter DBW) {
- LLVM_DEBUG(dbgs() << " Writing " << DBW.getSize() << " bytes to "
- << format("0x%016x", DBW.getDst()) << "\n");
- return Error::success();
- }
-
- Error handleWritePtr(JITTargetAddress Addr, JITTargetAddress PtrVal) {
- LLVM_DEBUG(dbgs() << " Writing pointer *" << format("0x%016x", Addr)
- << " = " << format("0x%016x", PtrVal) << "\n");
- uintptr_t *Ptr =
- reinterpret_cast<uintptr_t *>(static_cast<uintptr_t>(Addr));
- *Ptr = static_cast<uintptr_t>(PtrVal);
- return Error::success();
- }
-
- SymbolLookupFtor SymbolLookup;
- EHFrameRegistrationFtor EHFramesRegister, EHFramesDeregister;
- std::map<ResourceIdMgr::ResourceId, Allocator> Allocators;
- using ISBlockOwnerList = std::vector<LocalIndirectStubsInfo<TargetT>>;
- std::map<ResourceIdMgr::ResourceId, ISBlockOwnerList> IndirectStubsOwners;
- sys::OwningMemoryBlock ResolverBlock;
- std::vector<sys::OwningMemoryBlock> TrampolineBlocks;
- bool TerminateFlag = false;
-};
-
-} // end namespace remote
-} // end namespace orc
-} // end namespace llvm
-
-#undef DEBUG_TYPE
-
-#endif // LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETSERVER_H
More information about the llvm-commits
mailing list