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 "RPCUtils.h" 20 #include "RawByteChannel.h" 21 #include "llvm/ExecutionEngine/JITSymbol.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, JITTargetAddress Dst, uint64_t Size) 31 : Src(Src), Dst(Dst), Size(Size) {} 32 33 const char *getSrc() const { return Src; } 34 JITTargetAddress getDst() const { return Dst; } 35 uint64_t getSize() const { return Size; } 36 37 private: 38 const char *Src; 39 JITTargetAddress Dst; 40 uint64_t Size; 41 }; 42 43 } // end namespace remote 44 45 namespace rpc { 46 47 template <> class RPCTypeName<remote::DirectBufferWriter> { 48 public: 49 static const char *getName() { return "DirectBufferWriter"; } 50 }; 51 52 template <typename ChannelT> 53 class SerializationTraits< 54 ChannelT, remote::DirectBufferWriter, remote::DirectBufferWriter, 55 typename std::enable_if< 56 std::is_base_of<RawByteChannel, ChannelT>::value>::type> { 57 public: 58 static Error serialize(ChannelT &C, const remote::DirectBufferWriter &DBW) { 59 if (auto EC = serializeSeq(C, DBW.getDst())) 60 return EC; 61 if (auto EC = serializeSeq(C, DBW.getSize())) 62 return EC; 63 return C.appendBytes(DBW.getSrc(), DBW.getSize()); 64 } 65 66 static Error deserialize(ChannelT &C, remote::DirectBufferWriter &DBW) { 67 JITTargetAddress Dst; 68 if (auto EC = deserializeSeq(C, Dst)) 69 return EC; 70 uint64_t Size; 71 if (auto EC = deserializeSeq(C, Size)) 72 return EC; 73 char *Addr = reinterpret_cast<char *>(static_cast<uintptr_t>(Dst)); 74 75 DBW = remote::DirectBufferWriter(0, Dst, Size); 76 77 return C.readBytes(Addr, Size); 78 } 79 }; 80 81 } // end namespace rpc 82 83 namespace remote { 84 85 class OrcRemoteTargetRPCAPI 86 : public rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel> { 87 protected: 88 class ResourceIdMgr { 89 public: 90 typedef uint64_t ResourceId; 91 static const ResourceId InvalidId = ~0U; 92 93 ResourceId getNext() { 94 if (!FreeIds.empty()) { 95 ResourceId I = FreeIds.back(); 96 FreeIds.pop_back(); 97 return I; 98 } 99 return NextId++; 100 } 101 void release(ResourceId I) { FreeIds.push_back(I); } 102 103 private: 104 ResourceId NextId = 0; 105 std::vector<ResourceId> FreeIds; 106 }; 107 108 public: 109 // FIXME: Remove constructors once MSVC supports synthesizing move-ops. 110 OrcRemoteTargetRPCAPI(rpc::RawByteChannel &C) 111 : rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel>(C, true) {} 112 113 class CallIntVoid 114 : public rpc::Function<CallIntVoid, int32_t(JITTargetAddress Addr)> { 115 public: 116 static const char *getName() { return "CallIntVoid"; } 117 }; 118 119 class CallMain 120 : public rpc::Function<CallMain, int32_t(JITTargetAddress Addr, 121 std::vector<std::string> Args)> { 122 public: 123 static const char *getName() { return "CallMain"; } 124 }; 125 126 class CallVoidVoid 127 : public rpc::Function<CallVoidVoid, void(JITTargetAddress FnAddr)> { 128 public: 129 static const char *getName() { return "CallVoidVoid"; } 130 }; 131 132 class CreateRemoteAllocator 133 : public rpc::Function<CreateRemoteAllocator, 134 void(ResourceIdMgr::ResourceId AllocatorID)> { 135 public: 136 static const char *getName() { return "CreateRemoteAllocator"; } 137 }; 138 139 class CreateIndirectStubsOwner 140 : public rpc::Function<CreateIndirectStubsOwner, 141 void(ResourceIdMgr::ResourceId StubOwnerID)> { 142 public: 143 static const char *getName() { return "CreateIndirectStubsOwner"; } 144 }; 145 146 class DeregisterEHFrames 147 : public rpc::Function<DeregisterEHFrames, 148 void(JITTargetAddress Addr, uint32_t Size)> { 149 public: 150 static const char *getName() { return "DeregisterEHFrames"; } 151 }; 152 153 class DestroyRemoteAllocator 154 : public rpc::Function<DestroyRemoteAllocator, 155 void(ResourceIdMgr::ResourceId AllocatorID)> { 156 public: 157 static const char *getName() { return "DestroyRemoteAllocator"; } 158 }; 159 160 class DestroyIndirectStubsOwner 161 : public rpc::Function<DestroyIndirectStubsOwner, 162 void(ResourceIdMgr::ResourceId StubsOwnerID)> { 163 public: 164 static const char *getName() { return "DestroyIndirectStubsOwner"; } 165 }; 166 167 /// EmitIndirectStubs result is (StubsBase, PtrsBase, NumStubsEmitted). 168 class EmitIndirectStubs 169 : public rpc::Function< 170 EmitIndirectStubs, 171 std::tuple<JITTargetAddress, JITTargetAddress, uint32_t>( 172 ResourceIdMgr::ResourceId StubsOwnerID, 173 uint32_t NumStubsRequired)> { 174 public: 175 static const char *getName() { return "EmitIndirectStubs"; } 176 }; 177 178 class EmitResolverBlock : public rpc::Function<EmitResolverBlock, void()> { 179 public: 180 static const char *getName() { return "EmitResolverBlock"; } 181 }; 182 183 /// EmitTrampolineBlock result is (BlockAddr, NumTrampolines). 184 class EmitTrampolineBlock 185 : public rpc::Function<EmitTrampolineBlock, 186 std::tuple<JITTargetAddress, uint32_t>()> { 187 public: 188 static const char *getName() { return "EmitTrampolineBlock"; } 189 }; 190 191 class GetSymbolAddress 192 : public rpc::Function<GetSymbolAddress, 193 JITTargetAddress(std::string SymbolName)> { 194 public: 195 static const char *getName() { return "GetSymbolAddress"; } 196 }; 197 198 /// GetRemoteInfo result is (Triple, PointerSize, PageSize, TrampolineSize, 199 /// IndirectStubsSize). 200 class GetRemoteInfo 201 : public rpc::Function< 202 GetRemoteInfo, 203 std::tuple<std::string, uint32_t, uint32_t, uint32_t, uint32_t>()> { 204 public: 205 static const char *getName() { return "GetRemoteInfo"; } 206 }; 207 208 class ReadMem 209 : public rpc::Function<ReadMem, std::vector<uint8_t>(JITTargetAddress Src, 210 uint64_t Size)> { 211 public: 212 static const char *getName() { return "ReadMem"; } 213 }; 214 215 class RegisterEHFrames 216 : public rpc::Function<RegisterEHFrames, 217 void(JITTargetAddress Addr, uint32_t Size)> { 218 public: 219 static const char *getName() { return "RegisterEHFrames"; } 220 }; 221 222 class ReserveMem 223 : public rpc::Function<ReserveMem, 224 JITTargetAddress(ResourceIdMgr::ResourceId AllocID, 225 uint64_t Size, uint32_t Align)> { 226 public: 227 static const char *getName() { return "ReserveMem"; } 228 }; 229 230 class RequestCompile 231 : public rpc::Function< 232 RequestCompile, JITTargetAddress(JITTargetAddress TrampolineAddr)> { 233 public: 234 static const char *getName() { return "RequestCompile"; } 235 }; 236 237 class SetProtections 238 : public rpc::Function<SetProtections, 239 void(ResourceIdMgr::ResourceId AllocID, 240 JITTargetAddress Dst, uint32_t ProtFlags)> { 241 public: 242 static const char *getName() { return "SetProtections"; } 243 }; 244 245 class TerminateSession : public rpc::Function<TerminateSession, void()> { 246 public: 247 static const char *getName() { return "TerminateSession"; } 248 }; 249 250 class WriteMem 251 : public rpc::Function<WriteMem, void(remote::DirectBufferWriter DB)> { 252 public: 253 static const char *getName() { return "WriteMem"; } 254 }; 255 256 class WritePtr : public rpc::Function<WritePtr, void(JITTargetAddress Dst, 257 JITTargetAddress Val)> { 258 public: 259 static const char *getName() { return "WritePtr"; } 260 }; 261 }; 262 263 } // end namespace remote 264 } // end namespace orc 265 } // end namespace llvm 266 267 #endif 268
