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

Generated by: LCOV version 1.13