LCOV - code coverage report
Current view: top level - include/llvm/ExecutionEngine/Orc - OrcRemoteTargetRPCAPI.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 28 32 87.5 %
Date: 2018-10-14 09:39:32 Functions: 5 8 62.5 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "llvm/ExecutionEngine/JITSymbol.h"
      20             : #include "llvm/ExecutionEngine/Orc/RPCUtils.h"
      21             : #include "llvm/ExecutionEngine/Orc/RawByteChannel.h"
      22             : 
      23             : namespace llvm {
      24             : namespace orc {
      25             : 
      26             : namespace remote {
      27             : 
      28             : /// Template error for missing resources.
      29             : template <typename ResourceIdT>
      30             : class ResourceNotFound
      31             :   : public ErrorInfo<ResourceNotFound<ResourceIdT>> {
      32             : public:
      33             :   static char ID;
      34             : 
      35           2 :   ResourceNotFound(ResourceIdT ResourceId,
      36             :                    std::string ResourceDescription = "")
      37             :     : ResourceId(std::move(ResourceId)),
      38           2 :       ResourceDescription(std::move(ResourceDescription)) {}
      39             : 
      40           2 :   std::error_code convertToErrorCode() const override {
      41           2 :     return orcError(OrcErrorCode::UnknownResourceHandle);
      42             :   }
      43             : 
      44           4 :   void log(raw_ostream &OS) const override {
      45           4 :     OS << (ResourceDescription.empty()
      46             :              ? "Remote resource with id "
      47             :                : ResourceDescription)
      48           4 :        << " " << ResourceId << " not found";
      49           4 :   }
      50             : 
      51             : private:
      52             :   ResourceIdT ResourceId;
      53             :   std::string ResourceDescription;
      54             : };
      55             : 
      56             : template <typename ResourceIdT>
      57             : char ResourceNotFound<ResourceIdT>::ID = 0;
      58             : 
      59             : class DirectBufferWriter {
      60             : public:
      61             :   DirectBufferWriter() = default;
      62             :   DirectBufferWriter(const char *Src, JITTargetAddress Dst, uint64_t Size)
      63          64 :       : Src(Src), Dst(Dst), Size(Size) {}
      64             : 
      65           0 :   const char *getSrc() const { return Src; }
      66           0 :   JITTargetAddress getDst() const { return Dst; }
      67           0 :   uint64_t getSize() const { return Size; }
      68             : 
      69             : private:
      70             :   const char *Src;
      71             :   JITTargetAddress Dst;
      72             :   uint64_t Size;
      73             : };
      74             : 
      75             : } // end namespace remote
      76             : 
      77             : namespace rpc {
      78             : 
      79             : template <>
      80             : class RPCTypeName<JITSymbolFlags> {
      81             : public:
      82             :   static const char *getName() { return "JITSymbolFlags"; }
      83             : };
      84             : 
      85             : template <typename ChannelT>
      86             : class SerializationTraits<ChannelT, JITSymbolFlags> {
      87             : public:
      88             : 
      89             :   static Error serialize(ChannelT &C, const JITSymbolFlags &Flags) {
      90           3 :     return serializeSeq(C, Flags.getRawFlagsValue(), Flags.getTargetFlags());
      91             :   }
      92             : 
      93           3 :   static Error deserialize(ChannelT &C, JITSymbolFlags &Flags) {
      94             :     JITSymbolFlags::UnderlyingType JITFlags;
      95             :     JITSymbolFlags::TargetFlagsType TargetFlags;
      96           3 :     if (auto Err = deserializeSeq(C, JITFlags, TargetFlags))
      97             :       return Err;
      98           3 :     Flags = JITSymbolFlags(static_cast<JITSymbolFlags::FlagNames>(JITFlags),
      99             :                            TargetFlags);
     100             :     return Error::success();
     101             :   }
     102             : };
     103             : 
     104             : template <> class RPCTypeName<remote::DirectBufferWriter> {
     105             : public:
     106             :   static const char *getName() { return "DirectBufferWriter"; }
     107             : };
     108             : 
     109             : template <typename ChannelT>
     110             : class SerializationTraits<
     111             :     ChannelT, remote::DirectBufferWriter, remote::DirectBufferWriter,
     112             :     typename std::enable_if<
     113             :         std::is_base_of<RawByteChannel, ChannelT>::value>::type> {
     114             : public:
     115          64 :   static Error serialize(ChannelT &C, const remote::DirectBufferWriter &DBW) {
     116         128 :     if (auto EC = serializeSeq(C, DBW.getDst()))
     117             :       return EC;
     118         128 :     if (auto EC = serializeSeq(C, DBW.getSize()))
     119             :       return EC;
     120          64 :     return C.appendBytes(DBW.getSrc(), DBW.getSize());
     121             :   }
     122             : 
     123          64 :   static Error deserialize(ChannelT &C, remote::DirectBufferWriter &DBW) {
     124             :     JITTargetAddress Dst;
     125          64 :     if (auto EC = deserializeSeq(C, Dst))
     126             :       return EC;
     127             :     uint64_t Size;
     128          64 :     if (auto EC = deserializeSeq(C, Size))
     129             :       return EC;
     130          64 :     char *Addr = reinterpret_cast<char *>(static_cast<uintptr_t>(Dst));
     131             : 
     132          64 :     DBW = remote::DirectBufferWriter(nullptr, Dst, Size);
     133             : 
     134          64 :     return C.readBytes(Addr, Size);
     135             :   }
     136             : };
     137             : 
     138             : } // end namespace rpc
     139             : 
     140             : namespace remote {
     141             : 
     142             : class ResourceIdMgr {
     143             : public:
     144             :   using ResourceId = uint64_t;
     145             :   static const ResourceId InvalidId = ~0U;
     146             : 
     147          48 :   ResourceIdMgr() = default;
     148             :   explicit ResourceIdMgr(ResourceId FirstValidId)
     149          24 :     : NextId(std::move(FirstValidId)) {}
     150             : 
     151             :   ResourceId getNext() {
     152          34 :     if (!FreeIds.empty()) {
     153           0 :       ResourceId I = FreeIds.back();
     154             :       FreeIds.pop_back();
     155             :       return I;
     156             :     }
     157             :     assert(NextId + 1 != ~0ULL && "All ids allocated");
     158          34 :     return NextId++;
     159             :   }
     160             : 
     161           2 :   void release(ResourceId I) { FreeIds.push_back(I); }
     162             : 
     163             : private:
     164             :   ResourceId NextId = 1;
     165             :   std::vector<ResourceId> FreeIds;
     166             : };
     167             : 
     168             : /// Registers EH frames on the remote.
     169             : namespace eh {
     170             : 
     171             :   /// Registers EH frames on the remote.
     172             :   class RegisterEHFrames
     173             :       : public rpc::Function<RegisterEHFrames,
     174             :                              void(JITTargetAddress Addr, uint32_t Size)> {
     175             :   public:
     176             :     static const char *getName() { return "RegisterEHFrames"; }
     177             :   };
     178             : 
     179             :   /// Deregisters EH frames on the remote.
     180             :   class DeregisterEHFrames
     181             :       : public rpc::Function<DeregisterEHFrames,
     182             :                              void(JITTargetAddress Addr, uint32_t Size)> {
     183             :   public:
     184             :     static const char *getName() { return "DeregisterEHFrames"; }
     185             :   };
     186             : 
     187             : } // end namespace eh
     188             : 
     189             : /// RPC functions for executing remote code.
     190             : namespace exec {
     191             : 
     192             :   /// Call an 'int32_t()'-type function on the remote, returns the called
     193             :   /// function's return value.
     194             :   class CallIntVoid
     195             :       : public rpc::Function<CallIntVoid, int32_t(JITTargetAddress Addr)> {
     196             :   public:
     197             :     static const char *getName() { return "CallIntVoid"; }
     198             :   };
     199             : 
     200             :   /// Call an 'int32_t(int32_t, char**)'-type function on the remote, returns the
     201             :   /// called function's return value.
     202             :   class CallMain
     203             :       : public rpc::Function<CallMain, int32_t(JITTargetAddress Addr,
     204             :                                                std::vector<std::string> Args)> {
     205             :   public:
     206             :     static const char *getName() { return "CallMain"; }
     207             :   };
     208             : 
     209             :   /// Calls a 'void()'-type function on the remote, returns when the called
     210             :   /// function completes.
     211             :   class CallVoidVoid
     212             :       : public rpc::Function<CallVoidVoid, void(JITTargetAddress FnAddr)> {
     213             :   public:
     214             :     static const char *getName() { return "CallVoidVoid"; }
     215             :   };
     216             : 
     217             : } // end namespace exec
     218             : 
     219             : /// RPC functions for remote memory management / inspection / modification.
     220             : namespace mem {
     221             : 
     222             :   /// Creates a memory allocator on the remote.
     223             :   class CreateRemoteAllocator
     224             :       : public rpc::Function<CreateRemoteAllocator,
     225             :                              void(ResourceIdMgr::ResourceId AllocatorID)> {
     226             :   public:
     227             :     static const char *getName() { return "CreateRemoteAllocator"; }
     228             :   };
     229             : 
     230             :   /// Destroys a remote allocator, freeing any memory allocated by it.
     231             :   class DestroyRemoteAllocator
     232             :       : public rpc::Function<DestroyRemoteAllocator,
     233             :                              void(ResourceIdMgr::ResourceId AllocatorID)> {
     234             :   public:
     235             :     static const char *getName() { return "DestroyRemoteAllocator"; }
     236             :   };
     237             : 
     238             :   /// Read a remote memory block.
     239             :   class ReadMem
     240             :       : public rpc::Function<ReadMem, std::vector<uint8_t>(JITTargetAddress Src,
     241             :                                                            uint64_t Size)> {
     242             :   public:
     243             :     static const char *getName() { return "ReadMem"; }
     244             :   };
     245             : 
     246             :   /// Reserve a block of memory on the remote via the given allocator.
     247             :   class ReserveMem
     248             :       : public rpc::Function<ReserveMem,
     249             :                              JITTargetAddress(ResourceIdMgr::ResourceId AllocID,
     250             :                                               uint64_t Size, uint32_t Align)> {
     251             :   public:
     252             :     static const char *getName() { return "ReserveMem"; }
     253             :   };
     254             : 
     255             :   /// Set the memory protection on a memory block.
     256             :   class SetProtections
     257             :       : public rpc::Function<SetProtections,
     258             :                              void(ResourceIdMgr::ResourceId AllocID,
     259             :                                   JITTargetAddress Dst, uint32_t ProtFlags)> {
     260             :   public:
     261             :     static const char *getName() { return "SetProtections"; }
     262             :   };
     263             : 
     264             :   /// Write to a remote memory block.
     265             :   class WriteMem
     266             :       : public rpc::Function<WriteMem, void(remote::DirectBufferWriter DB)> {
     267             :   public:
     268             :     static const char *getName() { return "WriteMem"; }
     269             :   };
     270             : 
     271             :   /// Write to a remote pointer.
     272             :   class WritePtr : public rpc::Function<WritePtr, void(JITTargetAddress Dst,
     273             :                                                        JITTargetAddress Val)> {
     274             :   public:
     275             :     static const char *getName() { return "WritePtr"; }
     276             :   };
     277             : 
     278             : } // end namespace mem
     279             : 
     280             : /// RPC functions for remote stub and trampoline management.
     281             : namespace stubs {
     282             : 
     283             :   /// Creates an indirect stub owner on the remote.
     284             :   class CreateIndirectStubsOwner
     285             :       : public rpc::Function<CreateIndirectStubsOwner,
     286             :                              void(ResourceIdMgr::ResourceId StubOwnerID)> {
     287             :   public:
     288             :     static const char *getName() { return "CreateIndirectStubsOwner"; }
     289             :   };
     290             : 
     291             :   /// RPC function for destroying an indirect stubs owner.
     292             :   class DestroyIndirectStubsOwner
     293             :       : public rpc::Function<DestroyIndirectStubsOwner,
     294             :                              void(ResourceIdMgr::ResourceId StubsOwnerID)> {
     295             :   public:
     296             :     static const char *getName() { return "DestroyIndirectStubsOwner"; }
     297             :   };
     298             : 
     299             :   /// EmitIndirectStubs result is (StubsBase, PtrsBase, NumStubsEmitted).
     300             :   class EmitIndirectStubs
     301             :       : public rpc::Function<
     302             :             EmitIndirectStubs,
     303             :             std::tuple<JITTargetAddress, JITTargetAddress, uint32_t>(
     304             :                 ResourceIdMgr::ResourceId StubsOwnerID,
     305             :                 uint32_t NumStubsRequired)> {
     306             :   public:
     307             :     static const char *getName() { return "EmitIndirectStubs"; }
     308             :   };
     309             : 
     310             :   /// RPC function to emit the resolver block and return its address.
     311             :   class EmitResolverBlock : public rpc::Function<EmitResolverBlock, void()> {
     312             :   public:
     313             :     static const char *getName() { return "EmitResolverBlock"; }
     314             :   };
     315             : 
     316             :   /// EmitTrampolineBlock result is (BlockAddr, NumTrampolines).
     317             :   class EmitTrampolineBlock
     318             :       : public rpc::Function<EmitTrampolineBlock,
     319             :                              std::tuple<JITTargetAddress, uint32_t>()> {
     320             :   public:
     321             :     static const char *getName() { return "EmitTrampolineBlock"; }
     322             :   };
     323             : 
     324             : } // end namespace stubs
     325             : 
     326             : /// Miscelaneous RPC functions for dealing with remotes.
     327             : namespace utils {
     328             : 
     329             :   /// GetRemoteInfo result is (Triple, PointerSize, PageSize, TrampolineSize,
     330             :   ///                          IndirectStubsSize).
     331             :   class GetRemoteInfo
     332             :       : public rpc::Function<
     333             :             GetRemoteInfo,
     334             :             std::tuple<std::string, uint32_t, uint32_t, uint32_t, uint32_t>()> {
     335             :   public:
     336             :     static const char *getName() { return "GetRemoteInfo"; }
     337             :   };
     338             : 
     339             :   /// Get the address of a remote symbol.
     340             :   class GetSymbolAddress
     341             :       : public rpc::Function<GetSymbolAddress,
     342             :                              JITTargetAddress(std::string SymbolName)> {
     343             :   public:
     344             :     static const char *getName() { return "GetSymbolAddress"; }
     345             :   };
     346             : 
     347             :   /// Request that the host execute a compile callback.
     348             :   class RequestCompile
     349             :       : public rpc::Function<
     350             :             RequestCompile, JITTargetAddress(JITTargetAddress TrampolineAddr)> {
     351             :   public:
     352             :     static const char *getName() { return "RequestCompile"; }
     353             :   };
     354             : 
     355             :   /// Notify the remote and terminate the session.
     356             :   class TerminateSession : public rpc::Function<TerminateSession, void()> {
     357             :   public:
     358             :     static const char *getName() { return "TerminateSession"; }
     359             :   };
     360             : 
     361             : } // namespace utils
     362             : 
     363             : class OrcRemoteTargetRPCAPI
     364             :     : public rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel> {
     365             : public:
     366             :   // FIXME: Remove constructors once MSVC supports synthesizing move-ops.
     367             :   OrcRemoteTargetRPCAPI(rpc::RawByteChannel &C)
     368             :       : rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel>(C, true) {}
     369             : };
     370             : 
     371             : } // end namespace remote
     372             : 
     373             : } // end namespace orc
     374             : } // end namespace llvm
     375             : 
     376             : #endif // LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETRPCAPI_H

Generated by: LCOV version 1.13