1 //===------ RemoteObjectLayer.h - Forwards objs to a remote -----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Forwards objects to a remote object layer via RPC.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_EXECUTIONENGINE_ORC_REMOTEOBJECTLAYER_H
15 #define LLVM_EXECUTIONENGINE_ORC_REMOTEOBJECTLAYER_H
17 #include "llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h"
18 #include "llvm/Object/ObjectFile.h"
19 #include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
25 /// RPC API needed by RemoteObjectClientLayer and RemoteObjectServerLayer.
26 class RemoteObjectLayerAPI {
29 using ObjHandleT = remote::ResourceIdMgr::ResourceId;
33 using RemoteSymbolId = remote::ResourceIdMgr::ResourceId;
34 using RemoteSymbol = std::pair<RemoteSymbolId, JITSymbolFlags>;
38 using BadSymbolHandleError = remote::ResourceNotFound<RemoteSymbolId>;
39 using BadObjectHandleError = remote::ResourceNotFound<ObjHandleT>;
43 static const ObjHandleT InvalidObjectHandleId = 0;
44 static const RemoteSymbolId NullSymbolId = 0;
47 : public rpc::Function<AddObject, Expected<ObjHandleT>(std::string)> {
49 static const char *getName() { return "AddObject"; }
53 : public rpc::Function<RemoveObject, Error(ObjHandleT)> {
55 static const char *getName() { return "RemoveObject"; }
59 : public rpc::Function<FindSymbol, Expected<RemoteSymbol>(std::string,
62 static const char *getName() { return "FindSymbol"; }
66 : public rpc::Function<FindSymbolIn,
67 Expected<RemoteSymbol>(ObjHandleT, std::string,
70 static const char *getName() { return "FindSymbolIn"; }
74 : public rpc::Function<EmitAndFinalize,
77 static const char *getName() { return "EmitAndFinalize"; }
81 : public rpc::Function<Lookup,
82 Expected<RemoteSymbol>(ObjHandleT, std::string)> {
84 static const char *getName() { return "Lookup"; }
87 class LookupInLogicalDylib
88 : public rpc::Function<LookupInLogicalDylib,
89 Expected<RemoteSymbol>(ObjHandleT, std::string)> {
91 static const char *getName() { return "LookupInLogicalDylib"; }
94 class ReleaseRemoteSymbol
95 : public rpc::Function<ReleaseRemoteSymbol, Error(RemoteSymbolId)> {
97 static const char *getName() { return "ReleaseRemoteSymbol"; }
100 class MaterializeRemoteSymbol
101 : public rpc::Function<MaterializeRemoteSymbol,
102 Expected<JITTargetAddress>(RemoteSymbolId)> {
104 static const char *getName() { return "MaterializeRemoteSymbol"; }
108 /// Base class containing common utilities for RemoteObjectClientLayer and
109 /// RemoteObjectServerLayer.
110 template <typename RPCEndpoint>
111 class RemoteObjectLayer : public RemoteObjectLayerAPI {
114 RemoteObjectLayer(RPCEndpoint &Remote,
115 std::function<void(Error)> ReportError)
116 : Remote(Remote), ReportError(std::move(ReportError)),
117 SymbolIdMgr(NullSymbolId + 1) {
118 using ThisT = RemoteObjectLayer<RPCEndpoint>;
119 Remote.template addHandler<ReleaseRemoteSymbol>(
120 *this, &ThisT::handleReleaseRemoteSymbol);
121 Remote.template addHandler<MaterializeRemoteSymbol>(
122 *this, &ThisT::handleMaterializeRemoteSymbol);
127 /// This class is used as the symbol materializer for JITSymbols returned by
128 /// RemoteObjectLayerClient/RemoteObjectLayerServer -- the materializer knows
129 /// how to call back to the other RPC endpoint to get the address when
131 class RemoteSymbolMaterializer {
134 /// Construct a RemoteSymbolMaterializer for the given RemoteObjectLayer
135 /// with the given Id.
136 RemoteSymbolMaterializer(RemoteObjectLayer &C,
140 RemoteSymbolMaterializer(const RemoteSymbolMaterializer &Other)
141 : C(Other.C), Id(Other.Id) {
142 // FIXME: This is a horrible, auto_ptr-style, copy-as-move operation.
143 // It should be removed as soon as LLVM has C++14's generalized
144 // lambda capture (at which point the materializer can be moved
145 // into the lambda in remoteToJITSymbol below).
146 const_cast<RemoteSymbolMaterializer&>(Other).Id = 0;
149 RemoteSymbolMaterializer&
150 operator=(const RemoteSymbolMaterializer&) = delete;
152 /// Release the remote symbol.
153 ~RemoteSymbolMaterializer() {
155 C.releaseRemoteSymbol(Id);
158 /// Materialize the symbol on the remote and get its address.
159 Expected<JITTargetAddress> materialize() {
160 auto Addr = C.materializeRemoteSymbol(Id);
166 RemoteObjectLayer &C;
170 /// Convenience function for getting a null remote symbol value.
171 RemoteSymbol nullRemoteSymbol() {
172 return RemoteSymbol(0, JITSymbolFlags());
175 /// Creates a StringError that contains a copy of Err's log message, then
176 /// sends that StringError to ReportError.
178 /// This allows us to locally log error messages for errors that will actually
179 /// be delivered to the remote.
180 Error teeLog(Error Err) {
181 return handleErrors(std::move(Err),
182 [this](std::unique_ptr<ErrorInfoBase> EIB) {
183 ReportError(make_error<StringError>(
185 EIB->convertToErrorCode()));
186 return Error(std::move(EIB));
190 Error badRemoteSymbolIdError(RemoteSymbolId Id) {
191 return make_error<BadSymbolHandleError>(Id, "Remote JIT Symbol");
194 Error badObjectHandleError(ObjHandleT H) {
195 return make_error<RemoteObjectLayerAPI::BadObjectHandleError>(
196 H, "Bad object handle");
199 /// Create a RemoteSymbol wrapping the given JITSymbol.
200 Expected<RemoteSymbol> jitSymbolToRemote(JITSymbol Sym) {
202 auto Id = SymbolIdMgr.getNext();
203 auto Flags = Sym.getFlags();
204 assert(!InUseSymbols.count(Id) && "Symbol id already in use");
205 InUseSymbols.insert(std::make_pair(Id, std::move(Sym)));
206 return RemoteSymbol(Id, Flags);
207 } else if (auto Err = Sym.takeError())
208 return teeLog(std::move(Err));
210 return nullRemoteSymbol();
213 /// Convert an Expected<RemoteSymbol> to a JITSymbol.
214 JITSymbol remoteToJITSymbol(Expected<RemoteSymbol> RemoteSymOrErr) {
215 if (RemoteSymOrErr) {
216 auto &RemoteSym = *RemoteSymOrErr;
217 if (RemoteSym == nullRemoteSymbol())
220 RemoteSymbolMaterializer RSM(*this, RemoteSym.first);
222 JITSymbol([RSM]() mutable { return RSM.materialize(); },
226 return RemoteSymOrErr.takeError();
230 std::function<void(Error)> ReportError;
234 /// Notify the remote to release the given JITSymbol.
235 void releaseRemoteSymbol(RemoteSymbolId Id) {
236 if (auto Err = Remote.template callB<ReleaseRemoteSymbol>(Id))
237 ReportError(std::move(Err));
240 /// Notify the remote to materialize the JITSymbol with the given Id and
241 /// return its address.
242 Expected<JITTargetAddress> materializeRemoteSymbol(RemoteSymbolId Id) {
243 return Remote.template callB<MaterializeRemoteSymbol>(Id);
246 /// Release the JITSymbol with the given Id.
247 Error handleReleaseRemoteSymbol(RemoteSymbolId Id) {
248 auto SI = InUseSymbols.find(Id);
249 if (SI != InUseSymbols.end()) {
250 InUseSymbols.erase(SI);
251 return Error::success();
253 return teeLog(badRemoteSymbolIdError(Id));
256 /// Run the materializer for the JITSymbol with the given Id and return its
258 Expected<JITTargetAddress> handleMaterializeRemoteSymbol(RemoteSymbolId Id) {
259 auto SI = InUseSymbols.find(Id);
260 if (SI != InUseSymbols.end()) {
261 auto AddrOrErr = SI->second.getAddress();
262 InUseSymbols.erase(SI);
263 SymbolIdMgr.release(Id);
267 return teeLog(AddrOrErr.takeError());
269 return teeLog(badRemoteSymbolIdError(Id));
273 remote::ResourceIdMgr SymbolIdMgr;
274 std::map<RemoteSymbolId, JITSymbol> InUseSymbols;
277 /// RemoteObjectClientLayer forwards the ORC Object Layer API over an RPC
280 /// This class can be used as the base layer of a JIT stack on the client and
281 /// will forward operations to a corresponding RemoteObjectServerLayer on the
282 /// server (which can be composed on top of a "real" object layer like
283 /// RTDyldObjectLinkingLayer to actually carry out the operations).
285 /// Sending relocatable objects to the server (rather than fully relocated
286 /// bits) allows JIT'd code to be cached on the server side and re-used in
287 /// subsequent JIT sessions.
288 template <typename RPCEndpoint>
289 class RemoteObjectClientLayer : public RemoteObjectLayer<RPCEndpoint> {
292 using AddObject = RemoteObjectLayerAPI::AddObject;
293 using RemoveObject = RemoteObjectLayerAPI::RemoveObject;
294 using FindSymbol = RemoteObjectLayerAPI::FindSymbol;
295 using FindSymbolIn = RemoteObjectLayerAPI::FindSymbolIn;
296 using EmitAndFinalize = RemoteObjectLayerAPI::EmitAndFinalize;
297 using Lookup = RemoteObjectLayerAPI::Lookup;
298 using LookupInLogicalDylib = RemoteObjectLayerAPI::LookupInLogicalDylib;
300 using RemoteObjectLayer<RPCEndpoint>::teeLog;
301 using RemoteObjectLayer<RPCEndpoint>::badObjectHandleError;
302 using RemoteObjectLayer<RPCEndpoint>::remoteToJITSymbol;
306 using ObjHandleT = RemoteObjectLayerAPI::ObjHandleT;
307 using RemoteSymbol = RemoteObjectLayerAPI::RemoteSymbol;
309 using ObjectPtr = std::unique_ptr<MemoryBuffer>;
311 /// Create a RemoteObjectClientLayer that communicates with a
312 /// RemoteObjectServerLayer instance via the given RPCEndpoint.
314 /// The ReportError functor can be used locally log errors that are intended
316 RemoteObjectClientLayer(RPCEndpoint &Remote,
317 std::function<void(Error)> ReportError)
318 : RemoteObjectLayer<RPCEndpoint>(Remote, std::move(ReportError)) {
319 using ThisT = RemoteObjectClientLayer<RPCEndpoint>;
320 Remote.template addHandler<Lookup>(*this, &ThisT::lookup);
321 Remote.template addHandler<LookupInLogicalDylib>(
322 *this, &ThisT::lookupInLogicalDylib);
325 /// Add an object to the JIT.
327 /// @return A handle that can be used to refer to the loaded object (for
328 /// symbol searching, finalization, freeing memory, etc.).
330 addObject(ObjectPtr ObjBuffer,
331 std::shared_ptr<LegacyJITSymbolResolver> Resolver) {
332 if (auto HandleOrErr =
333 this->Remote.template callB<AddObject>(ObjBuffer->getBuffer())) {
334 auto &Handle = *HandleOrErr;
335 // FIXME: Return an error for this:
336 assert(!Resolvers.count(Handle) && "Handle already in use?");
337 Resolvers[Handle] = std::move(Resolver);
340 return HandleOrErr.takeError();
343 /// Remove the given object from the JIT.
344 Error removeObject(ObjHandleT H) {
345 return this->Remote.template callB<RemoveObject>(H);
348 /// Search for the given named symbol.
349 JITSymbol findSymbol(StringRef Name, bool ExportedSymbolsOnly) {
350 return remoteToJITSymbol(
351 this->Remote.template callB<FindSymbol>(Name,
352 ExportedSymbolsOnly));
355 /// Search for the given named symbol within the given context.
356 JITSymbol findSymbolIn(ObjHandleT H, StringRef Name, bool ExportedSymbolsOnly) {
357 return remoteToJITSymbol(
358 this->Remote.template callB<FindSymbolIn>(H, Name,
359 ExportedSymbolsOnly));
362 /// Immediately emit and finalize the object with the given handle.
363 Error emitAndFinalize(ObjHandleT H) {
364 return this->Remote.template callB<EmitAndFinalize>(H);
369 Expected<RemoteSymbol> lookup(ObjHandleT H, const std::string &Name) {
370 auto RI = Resolvers.find(H);
371 if (RI != Resolvers.end()) {
372 return this->jitSymbolToRemote(RI->second->findSymbol(Name));
374 return teeLog(badObjectHandleError(H));
377 Expected<RemoteSymbol> lookupInLogicalDylib(ObjHandleT H,
378 const std::string &Name) {
379 auto RI = Resolvers.find(H);
380 if (RI != Resolvers.end())
381 return this->jitSymbolToRemote(
382 RI->second->findSymbolInLogicalDylib(Name));
384 return teeLog(badObjectHandleError(H));
387 std::map<remote::ResourceIdMgr::ResourceId,
388 std::shared_ptr<LegacyJITSymbolResolver>>
392 /// RemoteObjectServerLayer acts as a server and handling RPC calls for the
393 /// object layer API from the given RPC connection.
395 /// This class can be composed on top of a 'real' object layer (e.g.
396 /// RTDyldObjectLinkingLayer) to do the actual work of relocating objects
397 /// and making them executable.
398 template <typename BaseLayerT, typename RPCEndpoint>
399 class RemoteObjectServerLayer : public RemoteObjectLayer<RPCEndpoint> {
402 using ObjHandleT = RemoteObjectLayerAPI::ObjHandleT;
403 using RemoteSymbol = RemoteObjectLayerAPI::RemoteSymbol;
405 using AddObject = RemoteObjectLayerAPI::AddObject;
406 using RemoveObject = RemoteObjectLayerAPI::RemoveObject;
407 using FindSymbol = RemoteObjectLayerAPI::FindSymbol;
408 using FindSymbolIn = RemoteObjectLayerAPI::FindSymbolIn;
409 using EmitAndFinalize = RemoteObjectLayerAPI::EmitAndFinalize;
410 using Lookup = RemoteObjectLayerAPI::Lookup;
411 using LookupInLogicalDylib = RemoteObjectLayerAPI::LookupInLogicalDylib;
413 using RemoteObjectLayer<RPCEndpoint>::teeLog;
414 using RemoteObjectLayer<RPCEndpoint>::badObjectHandleError;
415 using RemoteObjectLayer<RPCEndpoint>::remoteToJITSymbol;
419 /// Create a RemoteObjectServerLayer with the given base layer (which must be
420 /// an object layer), RPC endpoint, and error reporter function.
421 RemoteObjectServerLayer(BaseLayerT &BaseLayer,
423 std::function<void(Error)> ReportError)
424 : RemoteObjectLayer<RPCEndpoint>(Remote, std::move(ReportError)),
425 BaseLayer(BaseLayer), HandleIdMgr(1) {
426 using ThisT = RemoteObjectServerLayer<BaseLayerT, RPCEndpoint>;
428 Remote.template addHandler<AddObject>(*this, &ThisT::addObject);
429 Remote.template addHandler<RemoveObject>(*this, &ThisT::removeObject);
430 Remote.template addHandler<FindSymbol>(*this, &ThisT::findSymbol);
431 Remote.template addHandler<FindSymbolIn>(*this, &ThisT::findSymbolIn);
432 Remote.template addHandler<EmitAndFinalize>(*this, &ThisT::emitAndFinalize);
437 class StringMemoryBuffer : public MemoryBuffer {
439 StringMemoryBuffer(std::string Buffer)
440 : Buffer(std::move(Buffer)) {
441 init(this->Buffer.data(), this->Buffer.data() + this->Buffer.size(),
445 BufferKind getBufferKind() const override { return MemoryBuffer_Malloc; }
450 JITSymbol lookup(ObjHandleT Id, const std::string &Name) {
451 return remoteToJITSymbol(
452 this->Remote.template callB<Lookup>(Id, Name));
455 JITSymbol lookupInLogicalDylib(ObjHandleT Id, const std::string &Name) {
456 return remoteToJITSymbol(
457 this->Remote.template callB<LookupInLogicalDylib>(Id, Name));
460 Expected<ObjHandleT> addObject(std::string ObjBuffer) {
461 auto Buffer = llvm::make_unique<StringMemoryBuffer>(std::move(ObjBuffer));
462 auto Id = HandleIdMgr.getNext();
463 assert(!BaseLayerHandles.count(Id) && "Id already in use?");
465 auto Resolver = createLambdaResolver(
466 [this, Id](const std::string &Name) { return lookup(Id, Name); },
467 [this, Id](const std::string &Name) {
468 return lookupInLogicalDylib(Id, Name);
471 if (auto HandleOrErr =
472 BaseLayer.addObject(std::move(Buffer), std::move(Resolver))) {
473 BaseLayerHandles[Id] = std::move(*HandleOrErr);
476 return teeLog(HandleOrErr.takeError());
479 Error removeObject(ObjHandleT H) {
480 auto HI = BaseLayerHandles.find(H);
481 if (HI != BaseLayerHandles.end()) {
482 if (auto Err = BaseLayer.removeObject(HI->second))
483 return teeLog(std::move(Err));
484 return Error::success();
486 return teeLog(badObjectHandleError(H));
489 Expected<RemoteSymbol> findSymbol(const std::string &Name,
490 bool ExportedSymbolsOnly) {
491 if (auto Sym = BaseLayer.findSymbol(Name, ExportedSymbolsOnly))
492 return this->jitSymbolToRemote(std::move(Sym));
493 else if (auto Err = Sym.takeError())
494 return teeLog(std::move(Err));
495 return this->nullRemoteSymbol();
498 Expected<RemoteSymbol> findSymbolIn(ObjHandleT H, const std::string &Name,
499 bool ExportedSymbolsOnly) {
500 auto HI = BaseLayerHandles.find(H);
501 if (HI != BaseLayerHandles.end()) {
502 if (auto Sym = BaseLayer.findSymbolIn(HI->second, Name, ExportedSymbolsOnly))
503 return this->jitSymbolToRemote(std::move(Sym));
504 else if (auto Err = Sym.takeError())
505 return teeLog(std::move(Err));
506 return this->nullRemoteSymbol();
508 return teeLog(badObjectHandleError(H));
511 Error emitAndFinalize(ObjHandleT H) {
512 auto HI = BaseLayerHandles.find(H);
513 if (HI != BaseLayerHandles.end()) {
514 if (auto Err = BaseLayer.emitAndFinalize(HI->second))
515 return teeLog(std::move(Err));
516 return Error::success();
518 return teeLog(badObjectHandleError(H));
521 BaseLayerT &BaseLayer;
522 remote::ResourceIdMgr HandleIdMgr;
523 std::map<ObjHandleT, typename BaseLayerT::ObjHandleT> BaseLayerHandles;
526 } // end namespace orc
527 } // end namespace llvm
529 #endif // LLVM_EXECUTIONENGINE_ORC_REMOTEOBJECTLAYER_H