Orc/Shared/TargetProcessControlTypes.h

0001 //===--- TargetProcessControlTypes.h -- Shared Core/TPC types ---*- C++ -*-===//
0002 //
0003 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0004 // See https://llvm.org/LICENSE.txt for license information.
0005 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0006 //
0007 //===----------------------------------------------------------------------===//
0008 //
0009 // TargetProcessControl types that are used by both the Orc and
0010 // OrcTargetProcess libraries.
0011 //
0012 //===----------------------------------------------------------------------===//
0013
0014 #ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_TARGETPROCESSCONTROLTYPES_H
0015 #define LLVM_EXECUTIONENGINE_ORC_SHARED_TARGETPROCESSCONTROLTYPES_H
0016
0017 #include "llvm/ADT/ArrayRef.h"
0018 #include "llvm/ADT/StringRef.h"
0019 #include "llvm/ExecutionEngine/JITSymbol.h"
0020 #include "llvm/ExecutionEngine/Orc/Shared/AllocationActions.h"
0021 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
0022 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h"
0023 #include "llvm/ExecutionEngine/Orc/Shared/MemoryFlags.h"
0024 #include "llvm/ExecutionEngine/Orc/Shared/SimplePackedSerialization.h"
0025 #include "llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h"
0026 #include "llvm/Support/Memory.h"
0027
0028 #include <vector>
0029
0030 namespace llvm {
0031 namespace orc {
0032 namespace tpctypes {
0033
0034 struct RemoteAllocGroup {
0035   RemoteAllocGroup() = default;
0036   RemoteAllocGroup(MemProt Prot) : Prot(Prot) {}
0037   RemoteAllocGroup(MemProt Prot, bool FinalizeLifetime)
0038       : Prot(Prot), FinalizeLifetime(FinalizeLifetime) {}
0039   RemoteAllocGroup(const AllocGroup &AG) : Prot(AG.getMemProt()) {
0040     assert(AG.getMemLifetime() != orc::MemLifetime::NoAlloc &&
0041            "Cannot use no-alloc memory in a remote alloc request");
0042     FinalizeLifetime = AG.getMemLifetime() == orc::MemLifetime::Finalize;
0043   }
0044
0045   MemProt Prot;
0046   bool FinalizeLifetime = false;
0047 };
0048
0049 struct SegFinalizeRequest {
0050   RemoteAllocGroup RAG;
0051   ExecutorAddr Addr;
0052   uint64_t Size;
0053   ArrayRef<char> Content;
0054 };
0055
0056 struct FinalizeRequest {
0057   std::vector<SegFinalizeRequest> Segments;
0058   shared::AllocActions Actions;
0059 };
0060
0061 struct SharedMemorySegFinalizeRequest {
0062   RemoteAllocGroup RAG;
0063   ExecutorAddr Addr;
0064   uint64_t Size;
0065 };
0066
0067 struct SharedMemoryFinalizeRequest {
0068   std::vector<SharedMemorySegFinalizeRequest> Segments;
0069   shared::AllocActions Actions;
0070 };
0071
0072 template <typename T> struct UIntWrite {
0073   UIntWrite() = default;
0074   UIntWrite(ExecutorAddr Addr, T Value) : Addr(Addr), Value(Value) {}
0075
0076   ExecutorAddr Addr;
0077   T Value = 0;
0078 };
0079
0080 /// Describes a write to a uint8_t.
0081 using UInt8Write = UIntWrite<uint8_t>;
0082
0083 /// Describes a write to a uint16_t.
0084 using UInt16Write = UIntWrite<uint16_t>;
0085
0086 /// Describes a write to a uint32_t.
0087 using UInt32Write = UIntWrite<uint32_t>;
0088
0089 /// Describes a write to a uint64_t.
0090 using UInt64Write = UIntWrite<uint64_t>;
0091
0092 /// Describes a write to a buffer.
0093 /// For use with TargetProcessControl::MemoryAccess objects.
0094 struct BufferWrite {
0095   BufferWrite() = default;
0096   BufferWrite(ExecutorAddr Addr, StringRef Buffer)
0097       : Addr(Addr), Buffer(Buffer) {}
0098
0099   ExecutorAddr Addr;
0100   StringRef Buffer;
0101 };
0102
0103 /// Describes a write to a pointer.
0104 /// For use with TargetProcessControl::MemoryAccess objects.
0105 struct PointerWrite {
0106   PointerWrite() = default;
0107   PointerWrite(ExecutorAddr Addr, ExecutorAddr Value)
0108       : Addr(Addr), Value(Value) {}
0109
0110   ExecutorAddr Addr;
0111   ExecutorAddr Value;
0112 };
0113
0114 /// A handle used to represent a loaded dylib in the target process.
0115 using DylibHandle = ExecutorAddr;
0116
0117 using LookupResult = std::vector<ExecutorSymbolDef>;
0118
0119 } // end namespace tpctypes
0120
0121 namespace shared {
0122
0123 class SPSRemoteAllocGroup;
0124
0125 using SPSSegFinalizeRequest =
0126     SPSTuple<SPSRemoteAllocGroup, SPSExecutorAddr, uint64_t, SPSSequence<char>>;
0127
0128 using SPSFinalizeRequest = SPSTuple<SPSSequence<SPSSegFinalizeRequest>,
0129                                     SPSSequence<SPSAllocActionCallPair>>;
0130
0131 using SPSSharedMemorySegFinalizeRequest =
0132     SPSTuple<SPSRemoteAllocGroup, SPSExecutorAddr, uint64_t>;
0133
0134 using SPSSharedMemoryFinalizeRequest =
0135     SPSTuple<SPSSequence<SPSSharedMemorySegFinalizeRequest>,
0136              SPSSequence<SPSAllocActionCallPair>>;
0137
0138 template <typename T>
0139 using SPSMemoryAccessUIntWrite = SPSTuple<SPSExecutorAddr, T>;
0140
0141 using SPSMemoryAccessUInt8Write = SPSMemoryAccessUIntWrite<uint8_t>;
0142 using SPSMemoryAccessUInt16Write = SPSMemoryAccessUIntWrite<uint16_t>;
0143 using SPSMemoryAccessUInt32Write = SPSMemoryAccessUIntWrite<uint32_t>;
0144 using SPSMemoryAccessUInt64Write = SPSMemoryAccessUIntWrite<uint64_t>;
0145
0146 using SPSMemoryAccessBufferWrite = SPSTuple<SPSExecutorAddr, SPSSequence<char>>;
0147 using SPSMemoryAccessPointerWrite = SPSTuple<SPSExecutorAddr, SPSExecutorAddr>;
0148
0149 template <>
0150 class SPSSerializationTraits<SPSRemoteAllocGroup, tpctypes::RemoteAllocGroup> {
0151   enum WireBits {
0152     ReadBit = 1 << 0,
0153     WriteBit = 1 << 1,
0154     ExecBit = 1 << 2,
0155     FinalizeBit = 1 << 3
0156   };
0157
0158 public:
0159   static size_t size(const tpctypes::RemoteAllocGroup &RAG) {
0160     // All AllocGroup values encode to the same size.
0161     return SPSArgList<uint8_t>::size(uint8_t(0));
0162   }
0163
0164   static bool serialize(SPSOutputBuffer &OB,
0165                         const tpctypes::RemoteAllocGroup &RAG) {
0166     uint8_t WireValue = 0;
0167     if ((RAG.Prot & MemProt::Read) != MemProt::None)
0168       WireValue |= ReadBit;
0169     if ((RAG.Prot & MemProt::Write) != MemProt::None)
0170       WireValue |= WriteBit;
0171     if ((RAG.Prot & MemProt::Exec) != MemProt::None)
0172       WireValue |= ExecBit;
0173     if (RAG.FinalizeLifetime)
0174       WireValue |= FinalizeBit;
0175     return SPSArgList<uint8_t>::serialize(OB, WireValue);
0176   }
0177
0178   static bool deserialize(SPSInputBuffer &IB, tpctypes::RemoteAllocGroup &RAG) {
0179     uint8_t Val;
0180     if (!SPSArgList<uint8_t>::deserialize(IB, Val))
0181       return false;
0182     MemProt MP = MemProt::None;
0183     if (Val & ReadBit)
0184       MP |= MemProt::Read;
0185     if (Val & WriteBit)
0186       MP |= MemProt::Write;
0187     if (Val & ExecBit)
0188       MP |= MemProt::Exec;
0189     bool FinalizeLifetime = (Val & FinalizeBit) ? true : false;
0190     RAG = {MP, FinalizeLifetime};
0191     return true;
0192   }
0193 };
0194
0195 template <>
0196 class SPSSerializationTraits<SPSSegFinalizeRequest,
0197                              tpctypes::SegFinalizeRequest> {
0198   using SFRAL = SPSSegFinalizeRequest::AsArgList;
0199
0200 public:
0201   static size_t size(const tpctypes::SegFinalizeRequest &SFR) {
0202     return SFRAL::size(SFR.RAG, SFR.Addr, SFR.Size, SFR.Content);
0203   }
0204
0205   static bool serialize(SPSOutputBuffer &OB,
0206                         const tpctypes::SegFinalizeRequest &SFR) {
0207     return SFRAL::serialize(OB, SFR.RAG, SFR.Addr, SFR.Size, SFR.Content);
0208   }
0209
0210   static bool deserialize(SPSInputBuffer &IB,
0211                           tpctypes::SegFinalizeRequest &SFR) {
0212     return SFRAL::deserialize(IB, SFR.RAG, SFR.Addr, SFR.Size, SFR.Content);
0213   }
0214 };
0215
0216 template <>
0217 class SPSSerializationTraits<SPSFinalizeRequest, tpctypes::FinalizeRequest> {
0218   using FRAL = SPSFinalizeRequest::AsArgList;
0219
0220 public:
0221   static size_t size(const tpctypes::FinalizeRequest &FR) {
0222     return FRAL::size(FR.Segments, FR.Actions);
0223   }
0224
0225   static bool serialize(SPSOutputBuffer &OB,
0226                         const tpctypes::FinalizeRequest &FR) {
0227     return FRAL::serialize(OB, FR.Segments, FR.Actions);
0228   }
0229
0230   static bool deserialize(SPSInputBuffer &IB, tpctypes::FinalizeRequest &FR) {
0231     return FRAL::deserialize(IB, FR.Segments, FR.Actions);
0232   }
0233 };
0234
0235 template <>
0236 class SPSSerializationTraits<SPSSharedMemorySegFinalizeRequest,
0237                              tpctypes::SharedMemorySegFinalizeRequest> {
0238   using SFRAL = SPSSharedMemorySegFinalizeRequest::AsArgList;
0239
0240 public:
0241   static size_t size(const tpctypes::SharedMemorySegFinalizeRequest &SFR) {
0242     return SFRAL::size(SFR.RAG, SFR.Addr, SFR.Size);
0243   }
0244
0245   static bool serialize(SPSOutputBuffer &OB,
0246                         const tpctypes::SharedMemorySegFinalizeRequest &SFR) {
0247     return SFRAL::serialize(OB, SFR.RAG, SFR.Addr, SFR.Size);
0248   }
0249
0250   static bool deserialize(SPSInputBuffer &IB,
0251                           tpctypes::SharedMemorySegFinalizeRequest &SFR) {
0252     return SFRAL::deserialize(IB, SFR.RAG, SFR.Addr, SFR.Size);
0253   }
0254 };
0255
0256 template <>
0257 class SPSSerializationTraits<SPSSharedMemoryFinalizeRequest,
0258                              tpctypes::SharedMemoryFinalizeRequest> {
0259   using FRAL = SPSSharedMemoryFinalizeRequest::AsArgList;
0260
0261 public:
0262   static size_t size(const tpctypes::SharedMemoryFinalizeRequest &FR) {
0263     return FRAL::size(FR.Segments, FR.Actions);
0264   }
0265
0266   static bool serialize(SPSOutputBuffer &OB,
0267                         const tpctypes::SharedMemoryFinalizeRequest &FR) {
0268     return FRAL::serialize(OB, FR.Segments, FR.Actions);
0269   }
0270
0271   static bool deserialize(SPSInputBuffer &IB,
0272                           tpctypes::SharedMemoryFinalizeRequest &FR) {
0273     return FRAL::deserialize(IB, FR.Segments, FR.Actions);
0274   }
0275 };
0276
0277 template <typename T>
0278 class SPSSerializationTraits<SPSMemoryAccessUIntWrite<T>,
0279                              tpctypes::UIntWrite<T>> {
0280 public:
0281   static size_t size(const tpctypes::UIntWrite<T> &W) {
0282     return SPSTuple<SPSExecutorAddr, T>::AsArgList::size(W.Addr, W.Value);
0283   }
0284
0285   static bool serialize(SPSOutputBuffer &OB, const tpctypes::UIntWrite<T> &W) {
0286     return SPSTuple<SPSExecutorAddr, T>::AsArgList::serialize(OB, W.Addr,
0287                                                               W.Value);
0288   }
0289
0290   static bool deserialize(SPSInputBuffer &IB, tpctypes::UIntWrite<T> &W) {
0291     return SPSTuple<SPSExecutorAddr, T>::AsArgList::deserialize(IB, W.Addr,
0292                                                                 W.Value);
0293   }
0294 };
0295
0296 template <>
0297 class SPSSerializationTraits<SPSMemoryAccessBufferWrite,
0298                              tpctypes::BufferWrite> {
0299 public:
0300   static size_t size(const tpctypes::BufferWrite &W) {
0301     return SPSTuple<SPSExecutorAddr, SPSSequence<char>>::AsArgList::size(
0302         W.Addr, W.Buffer);
0303   }
0304
0305   static bool serialize(SPSOutputBuffer &OB, const tpctypes::BufferWrite &W) {
0306     return SPSTuple<SPSExecutorAddr, SPSSequence<char>>::AsArgList ::serialize(
0307         OB, W.Addr, W.Buffer);
0308   }
0309
0310   static bool deserialize(SPSInputBuffer &IB, tpctypes::BufferWrite &W) {
0311     return SPSTuple<SPSExecutorAddr,
0312                     SPSSequence<char>>::AsArgList ::deserialize(IB, W.Addr,
0313                                                                 W.Buffer);
0314   }
0315 };
0316
0317 template <>
0318 class SPSSerializationTraits<SPSMemoryAccessPointerWrite,
0319                              tpctypes::PointerWrite> {
0320 public:
0321   static size_t size(const tpctypes::PointerWrite &W) {
0322     return SPSTuple<SPSExecutorAddr, SPSExecutorAddr>::AsArgList::size(W.Addr,
0323                                                                        W.Value);
0324   }
0325
0326   static bool serialize(SPSOutputBuffer &OB, const tpctypes::PointerWrite &W) {
0327     return SPSTuple<SPSExecutorAddr, SPSExecutorAddr>::AsArgList::serialize(
0328         OB, W.Addr, W.Value);
0329   }
0330
0331   static bool deserialize(SPSInputBuffer &IB, tpctypes::PointerWrite &W) {
0332     return SPSTuple<SPSExecutorAddr, SPSExecutorAddr>::AsArgList::deserialize(
0333         IB, W.Addr, W.Value);
0334   }
0335 };
0336
0337 } // end namespace shared
0338 } // end namespace orc
0339 } // end namespace llvm
0340
0341 #endif // LLVM_EXECUTIONENGINE_ORC_SHARED_TARGETPROCESSCONTROLTYPES_H