include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h

   1 //===---- OrcRemoteTargetServer.h - Orc Remote-target Server ----*- 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 OrcRemoteTargetServer class. It can be used to build a
  11 // JIT server that can execute code sent from an OrcRemoteTargetClient.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETSERVER_H
  16 #define LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETSERVER_H
  17
  18 #include "OrcRemoteTargetRPCAPI.h"
  19 #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
  20 #include "llvm/Support/Debug.h"
  21 #include "llvm/Support/Format.h"
  22 #include "llvm/Support/Process.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include <map>
  25
  26 #define DEBUG_TYPE "orc-remote"
  27
  28 namespace llvm {
  29 namespace orc {
  30 namespace remote {
  31
  32 template <typename ChannelT, typename TargetT>
  33 class OrcRemoteTargetServer : public OrcRemoteTargetRPCAPI {
  34 public:
  35   typedef std::function<TargetAddress(const std::string &Name)>
  36       SymbolLookupFtor;
  37
  38   OrcRemoteTargetServer(ChannelT &Channel, SymbolLookupFtor SymbolLookup)
  39       : Channel(Channel), SymbolLookup(std::move(SymbolLookup)) {}
  40
  41   std::error_code getNextProcId(JITProcId &Id) {
  42     return deserialize(Channel, Id);
  43   }
  44
  45   std::error_code handleKnownProcedure(JITProcId Id) {
  46     DEBUG(dbgs() << "Handling known proc: " << getJITProcIdName(Id) << "\n");
  47
  48     switch (Id) {
  49     case CallIntVoidId:
  50       return handleCallIntVoid();
  51     case CallMainId:
  52       return handleCallMain();
  53     case CallVoidVoidId:
  54       return handleCallVoidVoid();
  55     case CreateRemoteAllocatorId:
  56       return handleCreateRemoteAllocator();
  57     case CreateIndirectStubsOwnerId:
  58       return handleCreateIndirectStubsOwner();
  59     case DestroyRemoteAllocatorId:
  60       return handleDestroyRemoteAllocator();
  61     case EmitIndirectStubsId:
  62       return handleEmitIndirectStubs();
  63     case EmitResolverBlockId:
  64       return handleEmitResolverBlock();
  65     case EmitTrampolineBlockId:
  66       return handleEmitTrampolineBlock();
  67     case GetSymbolAddressId:
  68       return handleGetSymbolAddress();
  69     case GetRemoteInfoId:
  70       return handleGetRemoteInfo();
  71     case ReadMemId:
  72       return handleReadMem();
  73     case ReserveMemId:
  74       return handleReserveMem();
  75     case SetProtectionsId:
  76       return handleSetProtections();
  77     case WriteMemId:
  78       return handleWriteMem();
  79     case WritePtrId:
  80       return handleWritePtr();
  81     default:
  82       return orcError(OrcErrorCode::UnexpectedRPCCall);
  83     }
  84
  85     llvm_unreachable("Unhandled JIT RPC procedure Id.");
  86   }
  87
  88   std::error_code requestCompile(TargetAddress &CompiledFnAddr,
  89                                  TargetAddress TrampolineAddr) {
  90     if (auto EC = call<RequestCompile>(Channel, TrampolineAddr))
  91       return EC;
  92
  93     while (1) {
  94       JITProcId Id = InvalidId;
  95       if (auto EC = getNextProcId(Id))
  96         return EC;
  97
  98       switch (Id) {
  99       case RequestCompileResponseId:
 100         return handle<RequestCompileResponse>(Channel,
 101                                               readArgs(CompiledFnAddr));
 102       default:
 103         if (auto EC = handleKnownProcedure(Id))
 104           return EC;
 105       }
 106     }
 107
 108     llvm_unreachable("Fell through request-compile command loop.");
 109   }
 110
 111 private:
 112   struct Allocator {
 113     Allocator() = default;
 114     Allocator(Allocator &&Other) : Allocs(std::move(Other.Allocs)) {}
 115     Allocator &operator=(Allocator &&Other) {
 116       Allocs = std::move(Other.Allocs);
 117       return *this;
 118     }
 119
 120     ~Allocator() {
 121       for (auto &Alloc : Allocs)
 122         sys::Memory::releaseMappedMemory(Alloc.second);
 123     }
 124
 125     std::error_code allocate(void *&Addr, size_t Size, uint32_t Align) {
 126       std::error_code EC;
 127       sys::MemoryBlock MB = sys::Memory::allocateMappedMemory(
 128           Size, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);
 129       if (EC)
 130         return EC;
 131
 132       Addr = MB.base();
 133       assert(Allocs.find(MB.base()) == Allocs.end() && "Duplicate alloc");
 134       Allocs[MB.base()] = std::move(MB);
 135       return std::error_code();
 136     }
 137
 138     std::error_code setProtections(void *block, unsigned Flags) {
 139       auto I = Allocs.find(block);
 140       if (I == Allocs.end())
 141         return orcError(OrcErrorCode::RemoteMProtectAddrUnrecognized);
 142       return sys::Memory::protectMappedMemory(I->second, Flags);
 143     }
 144
 145   private:
 146     std::map<void *, sys::MemoryBlock> Allocs;
 147   };
 148
 149   static std::error_code doNothing() { return std::error_code(); }
 150
 151   static TargetAddress reenter(void *JITTargetAddr, void *TrampolineAddr) {
 152     TargetAddress CompiledFnAddr = 0;
 153
 154     auto T = static_cast<OrcRemoteTargetServer *>(JITTargetAddr);
 155     auto EC = T->requestCompile(
 156         CompiledFnAddr, static_cast<TargetAddress>(
 157                             reinterpret_cast<uintptr_t>(TrampolineAddr)));
 158     assert(!EC && "Compile request failed");
 159     return CompiledFnAddr;
 160   }
 161
 162   std::error_code handleCallIntVoid() {
 163     typedef int (*IntVoidFnTy)();
 164
 165     IntVoidFnTy Fn = nullptr;
 166     if (auto EC = handle<CallIntVoid>(Channel, [&](TargetAddress Addr) {
 167           Fn = reinterpret_cast<IntVoidFnTy>(static_cast<uintptr_t>(Addr));
 168           return std::error_code();
 169         }))
 170       return EC;
 171
 172     DEBUG(dbgs() << "  Calling " << reinterpret_cast<void *>(Fn) << "\n");
 173     int Result = Fn();
 174     DEBUG(dbgs() << "  Result = " << Result << "\n");
 175
 176     return call<CallIntVoidResponse>(Channel, Result);
 177   }
 178
 179   std::error_code handleCallMain() {
 180     typedef int (*MainFnTy)(int, const char *[]);
 181
 182     MainFnTy Fn = nullptr;
 183     std::vector<std::string> Args;
 184     if (auto EC = handle<CallMain>(
 185             Channel, [&](TargetAddress Addr, std::vector<std::string> &A) {
 186               Fn = reinterpret_cast<MainFnTy>(static_cast<uintptr_t>(Addr));
 187               Args = std::move(A);
 188               return std::error_code();
 189             }))
 190       return EC;
 191
 192     int ArgC = Args.size() + 1;
 193     int Idx = 1;
 194     std::unique_ptr<const char *[]> ArgV(new const char *[ArgC + 1]);
 195     ArgV[0] = "<jit process>";
 196     for (auto &Arg : Args)
 197       ArgV[Idx++] = Arg.c_str();
 198
 199     DEBUG(dbgs() << "  Calling " << reinterpret_cast<void *>(Fn) << "\n");
 200     int Result = Fn(ArgC, ArgV.get());
 201     DEBUG(dbgs() << "  Result = " << Result << "\n");
 202
 203     return call<CallMainResponse>(Channel, Result);
 204   }
 205
 206   std::error_code handleCallVoidVoid() {
 207     typedef void (*VoidVoidFnTy)();
 208
 209     VoidVoidFnTy Fn = nullptr;
 210     if (auto EC = handle<CallIntVoid>(Channel, [&](TargetAddress Addr) {
 211           Fn = reinterpret_cast<VoidVoidFnTy>(static_cast<uintptr_t>(Addr));
 212           return std::error_code();
 213         }))
 214       return EC;
 215
 216     DEBUG(dbgs() << "  Calling " << reinterpret_cast<void *>(Fn) << "\n");
 217     Fn();
 218     DEBUG(dbgs() << "  Complete.\n");
 219
 220     return call<CallVoidVoidResponse>(Channel);
 221   }
 222
 223   std::error_code handleCreateRemoteAllocator() {
 224     return handle<CreateRemoteAllocator>(
 225         Channel, [&](ResourceIdMgr::ResourceId Id) {
 226           auto I = Allocators.find(Id);
 227           if (I != Allocators.end())
 228             return orcError(OrcErrorCode::RemoteAllocatorIdAlreadyInUse);
 229           DEBUG(dbgs() << "  Created allocator " << Id << "\n");
 230           Allocators[Id] = Allocator();
 231           return std::error_code();
 232         });
 233   }
 234
 235   std::error_code handleCreateIndirectStubsOwner() {
 236     return handle<CreateIndirectStubsOwner>(
 237         Channel, [&](ResourceIdMgr::ResourceId Id) {
 238           auto I = IndirectStubsOwners.find(Id);
 239           if (I != IndirectStubsOwners.end())
 240             return orcError(
 241                 OrcErrorCode::RemoteIndirectStubsOwnerIdAlreadyInUse);
 242           DEBUG(dbgs() << "  Create indirect stubs owner " << Id << "\n");
 243           IndirectStubsOwners[Id] = ISBlockOwnerList();
 244           return std::error_code();
 245         });
 246   }
 247
 248   std::error_code handleDestroyRemoteAllocator() {
 249     return handle<DestroyRemoteAllocator>(
 250         Channel, [&](ResourceIdMgr::ResourceId Id) {
 251           auto I = Allocators.find(Id);
 252           if (I == Allocators.end())
 253             return orcError(OrcErrorCode::RemoteAllocatorDoesNotExist);
 254           Allocators.erase(I);
 255           DEBUG(dbgs() << "  Destroyed allocator " << Id << "\n");
 256           return std::error_code();
 257         });
 258   }
 259
 260   std::error_code handleDestroyIndirectStubsOwner() {
 261     return handle<DestroyIndirectStubsOwner>(
 262         Channel, [&](ResourceIdMgr::ResourceId Id) {
 263           auto I = IndirectStubsOwners.find(Id);
 264           if (I == IndirectStubsOwners.end())
 265             return orcError(OrcErrorCode::RemoteIndirectStubsOwnerDoesNotExist);
 266           IndirectStubsOwners.erase(I);
 267           return std::error_code();
 268         });
 269   }
 270
 271   std::error_code handleEmitIndirectStubs() {
 272     ResourceIdMgr::ResourceId ISOwnerId = ~0U;
 273     uint32_t NumStubsRequired = 0;
 274
 275     if (auto EC = handle<EmitIndirectStubs>(
 276             Channel, readArgs(ISOwnerId, NumStubsRequired)))
 277       return EC;
 278
 279     DEBUG(dbgs() << "  ISMgr " << ISOwnerId << " request " << NumStubsRequired
 280                  << " stubs.\n");
 281
 282     auto StubOwnerItr = IndirectStubsOwners.find(ISOwnerId);
 283     if (StubOwnerItr == IndirectStubsOwners.end())
 284       return orcError(OrcErrorCode::RemoteIndirectStubsOwnerDoesNotExist);
 285
 286     typename TargetT::IndirectStubsInfo IS;
 287     if (auto EC =
 288             TargetT::emitIndirectStubsBlock(IS, NumStubsRequired, nullptr))
 289       return EC;
 290
 291     TargetAddress StubsBase =
 292         static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(IS.getStub(0)));
 293     TargetAddress PtrsBase =
 294         static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(IS.getPtr(0)));
 295     uint32_t NumStubsEmitted = IS.getNumStubs();
 296
 297     auto &BlockList = StubOwnerItr->second;
 298     BlockList.push_back(std::move(IS));
 299
 300     return call<EmitIndirectStubsResponse>(Channel, StubsBase, PtrsBase,
 301                                            NumStubsEmitted);
 302   }
 303
 304   std::error_code handleEmitResolverBlock() {
 305     if (auto EC = handle<EmitResolverBlock>(Channel, doNothing))
 306       return EC;
 307
 308     std::error_code EC;
 309     ResolverBlock = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
 310         TargetT::ResolverCodeSize, nullptr,
 311         sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
 312     if (EC)
 313       return EC;
 314
 315     TargetT::writeResolverCode(static_cast<uint8_t *>(ResolverBlock.base()),
 316                                &reenter, this);
 317
 318     return sys::Memory::protectMappedMemory(ResolverBlock.getMemoryBlock(),
 319                                             sys::Memory::MF_READ |
 320                                                 sys::Memory::MF_EXEC);
 321   }
 322
 323   std::error_code handleEmitTrampolineBlock() {
 324     if (auto EC = handle<EmitTrampolineBlock>(Channel, doNothing))
 325       return EC;
 326
 327     std::error_code EC;
 328
 329     auto TrampolineBlock =
 330         sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
 331             sys::Process::getPageSize(), nullptr,
 332             sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
 333     if (EC)
 334       return EC;
 335
 336     unsigned NumTrampolines =
 337         (sys::Process::getPageSize() - TargetT::PointerSize) /
 338         TargetT::TrampolineSize;
 339
 340     uint8_t *TrampolineMem = static_cast<uint8_t *>(TrampolineBlock.base());
 341     TargetT::writeTrampolines(TrampolineMem, ResolverBlock.base(),
 342                               NumTrampolines);
 343
 344     EC = sys::Memory::protectMappedMemory(TrampolineBlock.getMemoryBlock(),
 345                                           sys::Memory::MF_READ |
 346                                               sys::Memory::MF_EXEC);
 347
 348     TrampolineBlocks.push_back(std::move(TrampolineBlock));
 349
 350     return call<EmitTrampolineBlockResponse>(
 351         Channel,
 352         static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(TrampolineMem)),
 353         NumTrampolines);
 354   }
 355
 356   std::error_code handleGetSymbolAddress() {
 357     std::string SymbolName;
 358     if (auto EC = handle<GetSymbolAddress>(Channel, readArgs(SymbolName)))
 359       return EC;
 360
 361     TargetAddress SymbolAddr = SymbolLookup(SymbolName);
 362     DEBUG(dbgs() << "  Symbol '" << SymbolName
 363                  << "' =  " << format("0x%016x", SymbolAddr) << "\n");
 364     return call<GetSymbolAddressResponse>(Channel, SymbolAddr);
 365   }
 366
 367   std::error_code handleGetRemoteInfo() {
 368     if (auto EC = handle<GetRemoteInfo>(Channel, doNothing))
 369       return EC;
 370
 371     std::string ProcessTriple = sys::getProcessTriple();
 372     uint32_t PointerSize = TargetT::PointerSize;
 373     uint32_t PageSize = sys::Process::getPageSize();
 374     uint32_t TrampolineSize = TargetT::TrampolineSize;
 375     uint32_t IndirectStubSize = TargetT::IndirectStubsInfo::StubSize;
 376     DEBUG(dbgs() << "  Remote info:\n"
 377                  << "    triple             = '" << ProcessTriple << "'\n"
 378                  << "    pointer size       = " << PointerSize << "\n"
 379                  << "    page size          = " << PageSize << "\n"
 380                  << "    trampoline size    = " << TrampolineSize << "\n"
 381                  << "    indirect stub size = " << IndirectStubSize << "\n");
 382     return call<GetRemoteInfoResponse>(Channel, ProcessTriple, PointerSize,
 383                                        PageSize, TrampolineSize,
 384                                        IndirectStubSize);
 385   }
 386
 387   std::error_code handleReadMem() {
 388     char *Src = nullptr;
 389     uint64_t Size = 0;
 390     if (auto EC =
 391             handle<ReadMem>(Channel, [&](TargetAddress RSrc, uint64_t RSize) {
 392               Src = reinterpret_cast<char *>(static_cast<uintptr_t>(RSrc));
 393               Size = RSize;
 394               return std::error_code();
 395             }))
 396       return EC;
 397
 398     DEBUG(dbgs() << "  Reading " << Size << " bytes from "
 399                  << static_cast<void *>(Src) << "\n");
 400
 401     if (auto EC = call<ReadMemResponse>(Channel))
 402       return EC;
 403
 404     if (auto EC = Channel.appendBytes(Src, Size))
 405       return EC;
 406
 407     return Channel.send();
 408   }
 409
 410   std::error_code handleReserveMem() {
 411     void *LocalAllocAddr = nullptr;
 412
 413     if (auto EC =
 414             handle<ReserveMem>(Channel, [&](ResourceIdMgr::ResourceId Id,
 415                                             uint64_t Size, uint32_t Align) {
 416               auto I = Allocators.find(Id);
 417               if (I == Allocators.end())
 418                 return orcError(OrcErrorCode::RemoteAllocatorDoesNotExist);
 419               auto &Allocator = I->second;
 420               auto EC2 = Allocator.allocate(LocalAllocAddr, Size, Align);
 421               DEBUG(dbgs() << "  Allocator " << Id << " reserved "
 422                            << LocalAllocAddr << " (" << Size
 423                            << " bytes, alignment " << Align << ")\n");
 424               return EC2;
 425             }))
 426       return EC;
 427
 428     TargetAddress AllocAddr =
 429         static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(LocalAllocAddr));
 430
 431     return call<ReserveMemResponse>(Channel, AllocAddr);
 432   }
 433
 434   std::error_code handleSetProtections() {
 435     return handle<ReserveMem>(Channel, [&](ResourceIdMgr::ResourceId Id,
 436                                            TargetAddress Addr, uint32_t Flags) {
 437       auto I = Allocators.find(Id);
 438       if (I == Allocators.end())
 439         return orcError(OrcErrorCode::RemoteAllocatorDoesNotExist);
 440       auto &Allocator = I->second;
 441       void *LocalAddr = reinterpret_cast<void *>(static_cast<uintptr_t>(Addr));
 442       DEBUG(dbgs() << "  Allocator " << Id << " set permissions on "
 443                    << LocalAddr << " to "
 444                    << (Flags & sys::Memory::MF_READ ? 'R' : '-')
 445                    << (Flags & sys::Memory::MF_WRITE ? 'W' : '-')
 446                    << (Flags & sys::Memory::MF_EXEC ? 'X' : '-') << "\n");
 447       return Allocator.setProtections(LocalAddr, Flags);
 448     });
 449   }
 450
 451   std::error_code handleWriteMem() {
 452     return handle<WriteMem>(Channel, [&](TargetAddress RDst, uint64_t Size) {
 453       char *Dst = reinterpret_cast<char *>(static_cast<uintptr_t>(RDst));
 454       return Channel.readBytes(Dst, Size);
 455     });
 456   }
 457
 458   std::error_code handleWritePtr() {
 459     return handle<WritePtr>(
 460         Channel, [&](TargetAddress Addr, TargetAddress PtrVal) {
 461           uintptr_t *Ptr =
 462               reinterpret_cast<uintptr_t *>(static_cast<uintptr_t>(Addr));
 463           *Ptr = static_cast<uintptr_t>(PtrVal);
 464           return std::error_code();
 465         });
 466   }
 467
 468   ChannelT &Channel;
 469   SymbolLookupFtor SymbolLookup;
 470   std::map<ResourceIdMgr::ResourceId, Allocator> Allocators;
 471   typedef std::vector<typename TargetT::IndirectStubsInfo> ISBlockOwnerList;
 472   std::map<ResourceIdMgr::ResourceId, ISBlockOwnerList> IndirectStubsOwners;
 473   sys::OwningMemoryBlock ResolverBlock;
 474   std::vector<sys::OwningMemoryBlock> TrampolineBlocks;
 475 };
 476
 477 } // end namespace remote
 478 } // end namespace orc
 479 } // end namespace llvm
 480
 481 #undef DEBUG_TYPE
 482
 483 #endif