LLVM  4.0.0
OrcRemoteTargetRPCAPI.h
Go to the documentation of this file.
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"
22 
23 namespace llvm {
24 namespace orc {
25 namespace remote {
26 
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>
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 
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 
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.
111  : rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel>(C, true) {}
112 
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 
127  : public rpc::Function<CallVoidVoid, void(JITTargetAddress FnAddr)> {
128  public:
129  static const char *getName() { return "CallVoidVoid"; }
130  };
131 
133  : public rpc::Function<CreateRemoteAllocator,
134  void(ResourceIdMgr::ResourceId AllocatorID)> {
135  public:
136  static const char *getName() { return "CreateRemoteAllocator"; }
137  };
138 
140  : public rpc::Function<CreateIndirectStubsOwner,
141  void(ResourceIdMgr::ResourceId StubOwnerID)> {
142  public:
143  static const char *getName() { return "CreateIndirectStubsOwner"; }
144  };
145 
147  : public rpc::Function<DeregisterEHFrames,
148  void(JITTargetAddress Addr, uint32_t Size)> {
149  public:
150  static const char *getName() { return "DeregisterEHFrames"; }
151  };
152 
154  : public rpc::Function<DestroyRemoteAllocator,
155  void(ResourceIdMgr::ResourceId AllocatorID)> {
156  public:
157  static const char *getName() { return "DestroyRemoteAllocator"; }
158  };
159 
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).
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).
185  : public rpc::Function<EmitTrampolineBlock,
186  std::tuple<JITTargetAddress, uint32_t>()> {
187  public:
188  static const char *getName() { return "EmitTrampolineBlock"; }
189  };
190 
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).
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 
216  : public rpc::Function<RegisterEHFrames,
217  void(JITTargetAddress Addr, uint32_t Size)> {
218  public:
219  static const char *getName() { return "RegisterEHFrames"; }
220  };
221 
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 
231  : public rpc::Function<
232  RequestCompile, JITTargetAddress(JITTargetAddress TrampolineAddr)> {
233  public:
234  static const char *getName() { return "RequestCompile"; }
235  };
236 
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
EmitTrampolineBlock result is (BlockAddr, NumTrampolines).
GetRemoteInfo result is (Triple, PointerSize, PageSize, TrampolineSize, IndirectStubsSize).
Interface for byte-streams to be used with RPC.
The SerializationTraits<ChannelT, T> class describes how to serialize and deserialize an instance of ...
uint64_t JITTargetAddress
Represents an address in the target process's address space.
Definition: JITSymbol.h:33
EmitIndirectStubs result is (StubsBase, PtrsBase, NumStubsEmitted).
DirectBufferWriter(const char *Src, JITTargetAddress Dst, uint64_t Size)
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
Error deserializeSeq(ChannelT &C, ArgTs &...Args)
Basic Alias true
#define I(x, y, z)
Definition: MD5.cpp:54
Error serializeSeq(ChannelT &C, const ArgTs &...Args)
Lightweight error class with error context and mandatory checking.
SingleThreadedRPCEndpoint(rpc::RawByteChannel &C, bool LazyAutoNegotiation)
Definition: RPCUtils.h:1230