contrib/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h

   1 //===--- OrcRemoteTargetRPCAPI.h - Orc Remote-target RPC API ----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the Orc remote-target RPC API. It should not be used
  11 // directly, but is used by the RemoteTargetClient and RemoteTargetServer
  12 // classes.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETRPCAPI_H
  17 #define LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETRPCAPI_H
  18
  19 #include "JITSymbol.h"
  20 #include "RPCChannel.h"
  21 #include "RPCUtils.h"
  22
  23 namespace llvm {
  24 namespace orc {
  25 namespace remote {
  26
  27 class DirectBufferWriter {
  28 public:
  29   DirectBufferWriter() = default;
  30   DirectBufferWriter(const char *Src, TargetAddress Dst, uint64_t Size)
  31       : Src(Src), Dst(Dst), Size(Size) {}
  32
  33   const char *getSrc() const { return Src; }
  34   TargetAddress getDst() const { return Dst; }
  35   uint64_t getSize() const { return Size; }
  36
  37 private:
  38   const char *Src;
  39   TargetAddress Dst;
  40   uint64_t Size;
  41 };
  42
  43 inline Error serialize(RPCChannel &C, const DirectBufferWriter &DBW) {
  44   if (auto EC = serialize(C, DBW.getDst()))
  45     return EC;
  46   if (auto EC = serialize(C, DBW.getSize()))
  47     return EC;
  48   return C.appendBytes(DBW.getSrc(), DBW.getSize());
  49 }
  50
  51 inline Error deserialize(RPCChannel &C, DirectBufferWriter &DBW) {
  52   TargetAddress Dst;
  53   if (auto EC = deserialize(C, Dst))
  54     return EC;
  55   uint64_t Size;
  56   if (auto EC = deserialize(C, Size))
  57     return EC;
  58   char *Addr = reinterpret_cast<char *>(static_cast<uintptr_t>(Dst));
  59
  60   DBW = DirectBufferWriter(0, Dst, Size);
  61
  62   return C.readBytes(Addr, Size);
  63 }
  64
  65 class OrcRemoteTargetRPCAPI : public RPC<RPCChannel> {
  66 protected:
  67   class ResourceIdMgr {
  68   public:
  69     typedef uint64_t ResourceId;
  70     static const ResourceId InvalidId = ~0U;
  71
  72     ResourceId getNext() {
  73       if (!FreeIds.empty()) {
  74         ResourceId I = FreeIds.back();
  75         FreeIds.pop_back();
  76         return I;
  77       }
  78       return NextId++;
  79     }
  80     void release(ResourceId I) { FreeIds.push_back(I); }
  81
  82   private:
  83     ResourceId NextId = 0;
  84     std::vector<ResourceId> FreeIds;
  85   };
  86
  87 public:
  88   // FIXME: Remove constructors once MSVC supports synthesizing move-ops.
  89   OrcRemoteTargetRPCAPI() = default;
  90   OrcRemoteTargetRPCAPI(const OrcRemoteTargetRPCAPI &) = delete;
  91   OrcRemoteTargetRPCAPI &operator=(const OrcRemoteTargetRPCAPI &) = delete;
  92
  93   OrcRemoteTargetRPCAPI(OrcRemoteTargetRPCAPI &&) {}
  94   OrcRemoteTargetRPCAPI &operator=(OrcRemoteTargetRPCAPI &&) { return *this; }
  95
  96   enum JITFuncId : uint32_t {
  97     InvalidId = RPCFunctionIdTraits<JITFuncId>::InvalidId,
  98     CallIntVoidId = RPCFunctionIdTraits<JITFuncId>::FirstValidId,
  99     CallMainId,
 100     CallVoidVoidId,
 101     CreateRemoteAllocatorId,
 102     CreateIndirectStubsOwnerId,
 103     DeregisterEHFramesId,
 104     DestroyRemoteAllocatorId,
 105     DestroyIndirectStubsOwnerId,
 106     EmitIndirectStubsId,
 107     EmitResolverBlockId,
 108     EmitTrampolineBlockId,
 109     GetSymbolAddressId,
 110     GetRemoteInfoId,
 111     ReadMemId,
 112     RegisterEHFramesId,
 113     ReserveMemId,
 114     RequestCompileId,
 115     SetProtectionsId,
 116     TerminateSessionId,
 117     WriteMemId,
 118     WritePtrId
 119   };
 120
 121   static const char *getJITFuncIdName(JITFuncId Id);
 122
 123   typedef Function<CallIntVoidId, int32_t(TargetAddress Addr)> CallIntVoid;
 124
 125   typedef Function<CallMainId,
 126                    int32_t(TargetAddress Addr, std::vector<std::string> Args)>
 127       CallMain;
 128
 129   typedef Function<CallVoidVoidId, void(TargetAddress FnAddr)> CallVoidVoid;
 130
 131   typedef Function<CreateRemoteAllocatorId,
 132                    void(ResourceIdMgr::ResourceId AllocatorID)>
 133       CreateRemoteAllocator;
 134
 135   typedef Function<CreateIndirectStubsOwnerId,
 136                    void(ResourceIdMgr::ResourceId StubOwnerID)>
 137       CreateIndirectStubsOwner;
 138
 139   typedef Function<DeregisterEHFramesId,
 140                    void(TargetAddress Addr, uint32_t Size)>
 141       DeregisterEHFrames;
 142
 143   typedef Function<DestroyRemoteAllocatorId,
 144                    void(ResourceIdMgr::ResourceId AllocatorID)>
 145       DestroyRemoteAllocator;
 146
 147   typedef Function<DestroyIndirectStubsOwnerId,
 148                    void(ResourceIdMgr::ResourceId StubsOwnerID)>
 149       DestroyIndirectStubsOwner;
 150
 151   /// EmitIndirectStubs result is (StubsBase, PtrsBase, NumStubsEmitted).
 152   typedef Function<EmitIndirectStubsId,
 153                    std::tuple<TargetAddress, TargetAddress, uint32_t>(
 154                        ResourceIdMgr::ResourceId StubsOwnerID,
 155                        uint32_t NumStubsRequired)>
 156       EmitIndirectStubs;
 157
 158   typedef Function<EmitResolverBlockId, void()> EmitResolverBlock;
 159
 160   /// EmitTrampolineBlock result is (BlockAddr, NumTrampolines).
 161   typedef Function<EmitTrampolineBlockId, std::tuple<TargetAddress, uint32_t>()>
 162       EmitTrampolineBlock;
 163
 164   typedef Function<GetSymbolAddressId, TargetAddress(std::string SymbolName)>
 165       GetSymbolAddress;
 166
 167   /// GetRemoteInfo result is (Triple, PointerSize, PageSize, TrampolineSize,
 168   ///                          IndirectStubsSize).
 169   typedef Function<GetRemoteInfoId, std::tuple<std::string, uint32_t, uint32_t,
 170                                                uint32_t, uint32_t>()>
 171       GetRemoteInfo;
 172
 173   typedef Function<ReadMemId,
 174                    std::vector<char>(TargetAddress Src, uint64_t Size)>
 175       ReadMem;
 176
 177   typedef Function<RegisterEHFramesId, void(TargetAddress Addr, uint32_t Size)>
 178       RegisterEHFrames;
 179
 180   typedef Function<ReserveMemId,
 181                    TargetAddress(ResourceIdMgr::ResourceId AllocID,
 182                                  uint64_t Size, uint32_t Align)>
 183       ReserveMem;
 184
 185   typedef Function<RequestCompileId,
 186                    TargetAddress(TargetAddress TrampolineAddr)>
 187       RequestCompile;
 188
 189   typedef Function<SetProtectionsId,
 190                    void(ResourceIdMgr::ResourceId AllocID, TargetAddress Dst,
 191                         uint32_t ProtFlags)>
 192       SetProtections;
 193
 194   typedef Function<TerminateSessionId, void()> TerminateSession;
 195
 196   typedef Function<WriteMemId, void(DirectBufferWriter DB)> WriteMem;
 197
 198   typedef Function<WritePtrId, void(TargetAddress Dst, TargetAddress Val)>
 199       WritePtr;
 200 };
 201
 202 } // end namespace remote
 203 } // end namespace orc
 204 } // end namespace llvm
 205
 206 #endif