include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h

   1 //===---- OrcRemoteTargetClient.h - Orc Remote-target Client ----*- 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 OrcRemoteTargetClient class and helpers. This class
  11 // can be used to communicate over an RPCChannel with an OrcRemoteTargetServer
  12 // instance to support remote-JITing.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETCLIENT_H
  17 #define LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETCLIENT_H
  18
  19 #include "IndirectionUtils.h"
  20 #include "OrcRemoteTargetRPCAPI.h"
  21 #include <system_error>
  22
  23 #define DEBUG_TYPE "orc-remote"
  24
  25 namespace llvm {
  26 namespace orc {
  27 namespace remote {
  28
  29 /// This class provides utilities (including memory manager, indirect stubs
  30 /// manager, and compile callback manager types) that support remote JITing
  31 /// in ORC.
  32 ///
  33 /// Each of the utility classes talks to a JIT server (an instance of the
  34 /// OrcRemoteTargetServer class) via an RPC system (see RPCUtils.h) to carry out
  35 /// its actions.
  36 template <typename ChannelT>
  37 class OrcRemoteTargetClient : public OrcRemoteTargetRPCAPI {
  38 public:
  39   /// Remote memory manager.
  40   class RCMemoryManager : public RuntimeDyld::MemoryManager {
  41   public:
  42     RCMemoryManager(OrcRemoteTargetClient &Client, ResourceIdMgr::ResourceId Id)
  43         : Client(Client), Id(Id) {
  44       DEBUG(dbgs() << "Created remote allocator " << Id << "\n");
  45     }
  46
  47     RCMemoryManager(RCMemoryManager &&Other)
  48         : Client(std::move(Other.Client)), Id(std::move(Other.Id)),
  49           Unmapped(std::move(Other.Unmapped)),
  50           Unfinalized(std::move(Other.Unfinalized)) {}
  51
  52     RCMemoryManager operator=(RCMemoryManager &&Other) {
  53       Client = std::move(Other.Client);
  54       Id = std::move(Other.Id);
  55       Unmapped = std::move(Other.Unmapped);
  56       Unfinalized = std::move(Other.Unfinalized);
  57       return *this;
  58     }
  59
  60     ~RCMemoryManager() {
  61       Client.destroyRemoteAllocator(Id);
  62       DEBUG(dbgs() << "Destroyed remote allocator " << Id << "\n");
  63     }
  64
  65     uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
  66                                  unsigned SectionID,
  67                                  StringRef SectionName) override {
  68       Unmapped.back().CodeAllocs.emplace_back(Size, Alignment);
  69       uint8_t *Alloc = reinterpret_cast<uint8_t *>(
  70           Unmapped.back().CodeAllocs.back().getLocalAddress());
  71       DEBUG(dbgs() << "Allocator " << Id << " allocated code for "
  72                    << SectionName << ": " << Alloc << " (" << Size
  73                    << " bytes, alignment " << Alignment << ")\n");
  74       return Alloc;
  75     }
  76
  77     uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
  78                                  unsigned SectionID, StringRef SectionName,
  79                                  bool IsReadOnly) override {
  80       if (IsReadOnly) {
  81         Unmapped.back().RODataAllocs.emplace_back(Size, Alignment);
  82         uint8_t *Alloc = reinterpret_cast<uint8_t *>(
  83             Unmapped.back().RODataAllocs.back().getLocalAddress());
  84         DEBUG(dbgs() << "Allocator " << Id << " allocated ro-data for "
  85                      << SectionName << ": " << Alloc << " (" << Size
  86                      << " bytes, alignment " << Alignment << ")\n");
  87         return Alloc;
  88       } // else...
  89
  90       Unmapped.back().RWDataAllocs.emplace_back(Size, Alignment);
  91       uint8_t *Alloc = reinterpret_cast<uint8_t *>(
  92           Unmapped.back().RWDataAllocs.back().getLocalAddress());
  93       DEBUG(dbgs() << "Allocator " << Id << " allocated rw-data for "
  94                    << SectionName << ": " << Alloc << " (" << Size
  95                    << " bytes, alignment " << Alignment << "\n");
  96       return Alloc;
  97     }
  98
  99     void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
 100                                 uintptr_t RODataSize, uint32_t RODataAlign,
 101                                 uintptr_t RWDataSize,
 102                                 uint32_t RWDataAlign) override {
 103       Unmapped.push_back(ObjectAllocs());
 104
 105       DEBUG(dbgs() << "Allocator " << Id << " reserved:\n");
 106
 107       if (CodeSize != 0) {
 108         if (std::error_code EC = Client.reserveMem(
 109                 Unmapped.back().RemoteCodeAddr, Id, CodeSize, CodeAlign)) {
 110           (void)EC;
 111           // FIXME; Add error to poll.
 112           llvm_unreachable("Failed reserving remote memory.");
 113         }
 114         DEBUG(dbgs() << "  code: "
 115                      << format("0x%016x", Unmapped.back().RemoteCodeAddr)
 116                      << " (" << CodeSize << " bytes, alignment " << CodeAlign
 117                      << ")\n");
 118       }
 119
 120       if (RODataSize != 0) {
 121         if (auto EC = Client.reserveMem(Unmapped.back().RemoteRODataAddr, Id,
 122                                         RODataSize, RODataAlign)) {
 123           // FIXME; Add error to poll.
 124           llvm_unreachable("Failed reserving remote memory.");
 125         }
 126         DEBUG(dbgs() << "  ro-data: "
 127                      << format("0x%016x", Unmapped.back().RemoteRODataAddr)
 128                      << " (" << RODataSize << " bytes, alignment "
 129                      << RODataAlign << ")\n");
 130       }
 131
 132       if (RWDataSize != 0) {
 133         if (auto EC = Client.reserveMem(Unmapped.back().RemoteRWDataAddr, Id,
 134                                         RWDataSize, RWDataAlign)) {
 135           // FIXME; Add error to poll.
 136           llvm_unreachable("Failed reserving remote memory.");
 137         }
 138         DEBUG(dbgs() << "  rw-data: "
 139                      << format("0x%016x", Unmapped.back().RemoteRWDataAddr)
 140                      << " (" << RWDataSize << " bytes, alignment "
 141                      << RWDataAlign << ")\n");
 142       }
 143     }
 144
 145     bool needsToReserveAllocationSpace() override { return true; }
 146
 147     void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr,
 148                           size_t Size) override {}
 149
 150     void deregisterEHFrames(uint8_t *addr, uint64_t LoadAddr,
 151                             size_t Size) override {}
 152
 153     void notifyObjectLoaded(RuntimeDyld &Dyld,
 154                             const object::ObjectFile &Obj) override {
 155       DEBUG(dbgs() << "Allocator " << Id << " applied mappings:\n");
 156       for (auto &ObjAllocs : Unmapped) {
 157         {
 158           TargetAddress NextCodeAddr = ObjAllocs.RemoteCodeAddr;
 159           for (auto &Alloc : ObjAllocs.CodeAllocs) {
 160             NextCodeAddr = RoundUpToAlignment(NextCodeAddr, Alloc.getAlign());
 161             Dyld.mapSectionAddress(Alloc.getLocalAddress(), NextCodeAddr);
 162             DEBUG(dbgs() << "     code: "
 163                          << static_cast<void *>(Alloc.getLocalAddress())
 164                          << " -> " << format("0x%016x", NextCodeAddr) << "\n");
 165             Alloc.setRemoteAddress(NextCodeAddr);
 166             NextCodeAddr += Alloc.getSize();
 167           }
 168         }
 169         {
 170           TargetAddress NextRODataAddr = ObjAllocs.RemoteRODataAddr;
 171           for (auto &Alloc : ObjAllocs.RODataAllocs) {
 172             NextRODataAddr =
 173                 RoundUpToAlignment(NextRODataAddr, Alloc.getAlign());
 174             Dyld.mapSectionAddress(Alloc.getLocalAddress(), NextRODataAddr);
 175             DEBUG(dbgs() << "  ro-data: "
 176                          << static_cast<void *>(Alloc.getLocalAddress())
 177                          << " -> " << format("0x%016x", NextRODataAddr)
 178                          << "\n");
 179             Alloc.setRemoteAddress(NextRODataAddr);
 180             NextRODataAddr += Alloc.getSize();
 181           }
 182         }
 183         {
 184           TargetAddress NextRWDataAddr = ObjAllocs.RemoteRWDataAddr;
 185           for (auto &Alloc : ObjAllocs.RWDataAllocs) {
 186             NextRWDataAddr =
 187                 RoundUpToAlignment(NextRWDataAddr, Alloc.getAlign());
 188             Dyld.mapSectionAddress(Alloc.getLocalAddress(), NextRWDataAddr);
 189             DEBUG(dbgs() << "  rw-data: "
 190                          << static_cast<void *>(Alloc.getLocalAddress())
 191                          << " -> " << format("0x%016x", NextRWDataAddr)
 192                          << "\n");
 193             Alloc.setRemoteAddress(NextRWDataAddr);
 194             NextRWDataAddr += Alloc.getSize();
 195           }
 196         }
 197         Unfinalized.push_back(std::move(ObjAllocs));
 198       }
 199       Unmapped.clear();
 200     }
 201
 202     bool finalizeMemory(std::string *ErrMsg = nullptr) override {
 203       DEBUG(dbgs() << "Allocator " << Id << " finalizing:\n");
 204
 205       for (auto &ObjAllocs : Unfinalized) {
 206
 207         for (auto &Alloc : ObjAllocs.CodeAllocs) {
 208           DEBUG(dbgs() << "  copying code: "
 209                        << static_cast<void *>(Alloc.getLocalAddress()) << " -> "
 210                        << format("0x%016x", Alloc.getRemoteAddress()) << " ("
 211                        << Alloc.getSize() << " bytes)\n");
 212           Client.writeMem(Alloc.getRemoteAddress(), Alloc.getLocalAddress(),
 213                           Alloc.getSize());
 214         }
 215
 216         if (ObjAllocs.RemoteCodeAddr) {
 217           DEBUG(dbgs() << "  setting R-X permissions on code block: "
 218                        << format("0x%016x", ObjAllocs.RemoteCodeAddr) << "\n");
 219           Client.setProtections(Id, ObjAllocs.RemoteCodeAddr,
 220                                 sys::Memory::MF_READ | sys::Memory::MF_EXEC);
 221         }
 222
 223         for (auto &Alloc : ObjAllocs.RODataAllocs) {
 224           DEBUG(dbgs() << "  copying ro-data: "
 225                        << static_cast<void *>(Alloc.getLocalAddress()) << " -> "
 226                        << format("0x%016x", Alloc.getRemoteAddress()) << " ("
 227                        << Alloc.getSize() << " bytes)\n");
 228           Client.writeMem(Alloc.getRemoteAddress(), Alloc.getLocalAddress(),
 229                           Alloc.getSize());
 230         }
 231
 232         if (ObjAllocs.RemoteRODataAddr) {
 233           DEBUG(dbgs() << "  setting R-- permissions on ro-data block: "
 234                        << format("0x%016x", ObjAllocs.RemoteRODataAddr)
 235                        << "\n");
 236           Client.setProtections(Id, ObjAllocs.RemoteRODataAddr,
 237                                 sys::Memory::MF_READ);
 238         }
 239
 240         for (auto &Alloc : ObjAllocs.RWDataAllocs) {
 241           DEBUG(dbgs() << "  copying rw-data: "
 242                        << static_cast<void *>(Alloc.getLocalAddress()) << " -> "
 243                        << format("0x%016x", Alloc.getRemoteAddress()) << " ("
 244                        << Alloc.getSize() << " bytes)\n");
 245           Client.writeMem(Alloc.getRemoteAddress(), Alloc.getLocalAddress(),
 246                           Alloc.getSize());
 247         }
 248
 249         if (ObjAllocs.RemoteRWDataAddr) {
 250           DEBUG(dbgs() << "  setting RW- permissions on rw-data block: "
 251                        << format("0x%016x", ObjAllocs.RemoteRWDataAddr)
 252                        << "\n");
 253           Client.setProtections(Id, ObjAllocs.RemoteRWDataAddr,
 254                                 sys::Memory::MF_READ | sys::Memory::MF_WRITE);
 255         }
 256       }
 257       Unfinalized.clear();
 258
 259       return false;
 260     }
 261
 262   private:
 263     class Alloc {
 264     public:
 265       Alloc(uint64_t Size, unsigned Align)
 266           : Size(Size), Align(Align), Contents(new char[Size + Align - 1]),
 267             RemoteAddr(0) {}
 268
 269       Alloc(Alloc &&Other)
 270           : Size(std::move(Other.Size)), Align(std::move(Other.Align)),
 271             Contents(std::move(Other.Contents)),
 272             RemoteAddr(std::move(Other.RemoteAddr)) {}
 273
 274       Alloc &operator=(Alloc &&Other) {
 275         Size = std::move(Other.Size);
 276         Align = std::move(Other.Align);
 277         Contents = std::move(Other.Contents);
 278         RemoteAddr = std::move(Other.RemoteAddr);
 279         return *this;
 280       }
 281
 282       uint64_t getSize() const { return Size; }
 283
 284       unsigned getAlign() const { return Align; }
 285
 286       char *getLocalAddress() const {
 287         uintptr_t LocalAddr = reinterpret_cast<uintptr_t>(Contents.get());
 288         LocalAddr = RoundUpToAlignment(LocalAddr, Align);
 289         return reinterpret_cast<char *>(LocalAddr);
 290       }
 291
 292       void setRemoteAddress(TargetAddress RemoteAddr) {
 293         this->RemoteAddr = RemoteAddr;
 294       }
 295
 296       TargetAddress getRemoteAddress() const { return RemoteAddr; }
 297
 298     private:
 299       uint64_t Size;
 300       unsigned Align;
 301       std::unique_ptr<char[]> Contents;
 302       TargetAddress RemoteAddr;
 303     };
 304
 305     struct ObjectAllocs {
 306       ObjectAllocs()
 307           : RemoteCodeAddr(0), RemoteRODataAddr(0), RemoteRWDataAddr(0) {}
 308
 309       ObjectAllocs(ObjectAllocs &&Other)
 310           : RemoteCodeAddr(std::move(Other.RemoteCodeAddr)),
 311             RemoteRODataAddr(std::move(Other.RemoteRODataAddr)),
 312             RemoteRWDataAddr(std::move(Other.RemoteRWDataAddr)),
 313             CodeAllocs(std::move(Other.CodeAllocs)),
 314             RODataAllocs(std::move(Other.RODataAllocs)),
 315             RWDataAllocs(std::move(Other.RWDataAllocs)) {}
 316
 317       ObjectAllocs &operator=(ObjectAllocs &&Other) {
 318         RemoteCodeAddr = std::move(Other.RemoteCodeAddr);
 319         RemoteRODataAddr = std::move(Other.RemoteRODataAddr);
 320         RemoteRWDataAddr = std::move(Other.RemoteRWDataAddr);
 321         CodeAllocs = std::move(Other.CodeAllocs);
 322         RODataAllocs = std::move(Other.RODataAllocs);
 323         RWDataAllocs = std::move(Other.RWDataAllocs);
 324         return *this;
 325       }
 326
 327       TargetAddress RemoteCodeAddr;
 328       TargetAddress RemoteRODataAddr;
 329       TargetAddress RemoteRWDataAddr;
 330       std::vector<Alloc> CodeAllocs, RODataAllocs, RWDataAllocs;
 331     };
 332
 333     OrcRemoteTargetClient &Client;
 334     ResourceIdMgr::ResourceId Id;
 335     std::vector<ObjectAllocs> Unmapped;
 336     std::vector<ObjectAllocs> Unfinalized;
 337   };
 338
 339   /// Remote indirect stubs manager.
 340   class RCIndirectStubsManager : public IndirectStubsManager {
 341   public:
 342     RCIndirectStubsManager(OrcRemoteTargetClient &Remote,
 343                            ResourceIdMgr::ResourceId Id)
 344         : Remote(Remote), Id(Id) {}
 345
 346     ~RCIndirectStubsManager() { Remote.destroyIndirectStubsManager(Id); }
 347
 348     std::error_code createStub(StringRef StubName, TargetAddress StubAddr,
 349                                JITSymbolFlags StubFlags) override {
 350       if (auto EC = reserveStubs(1))
 351         return EC;
 352
 353       return createStubInternal(StubName, StubAddr, StubFlags);
 354     }
 355
 356     std::error_code createStubs(const StubInitsMap &StubInits) override {
 357       if (auto EC = reserveStubs(StubInits.size()))
 358         return EC;
 359
 360       for (auto &Entry : StubInits)
 361         if (auto EC = createStubInternal(Entry.first(), Entry.second.first,
 362                                          Entry.second.second))
 363           return EC;
 364
 365       return std::error_code();
 366     }
 367
 368     JITSymbol findStub(StringRef Name, bool ExportedStubsOnly) override {
 369       auto I = StubIndexes.find(Name);
 370       if (I == StubIndexes.end())
 371         return nullptr;
 372       auto Key = I->second.first;
 373       auto Flags = I->second.second;
 374       auto StubSymbol = JITSymbol(getStubAddr(Key), Flags);
 375       if (ExportedStubsOnly && !StubSymbol.isExported())
 376         return nullptr;
 377       return StubSymbol;
 378     }
 379
 380     JITSymbol findPointer(StringRef Name) override {
 381       auto I = StubIndexes.find(Name);
 382       if (I == StubIndexes.end())
 383         return nullptr;
 384       auto Key = I->second.first;
 385       auto Flags = I->second.second;
 386       return JITSymbol(getPtrAddr(Key), Flags);
 387     }
 388
 389     std::error_code updatePointer(StringRef Name,
 390                                   TargetAddress NewAddr) override {
 391       auto I = StubIndexes.find(Name);
 392       assert(I != StubIndexes.end() && "No stub pointer for symbol");
 393       auto Key = I->second.first;
 394       return Remote.writePointer(getPtrAddr(Key), NewAddr);
 395     }
 396
 397   private:
 398     struct RemoteIndirectStubsInfo {
 399       RemoteIndirectStubsInfo(TargetAddress StubBase, TargetAddress PtrBase,
 400                               unsigned NumStubs)
 401           : StubBase(StubBase), PtrBase(PtrBase), NumStubs(NumStubs) {}
 402       TargetAddress StubBase;
 403       TargetAddress PtrBase;
 404       unsigned NumStubs;
 405     };
 406
 407     OrcRemoteTargetClient &Remote;
 408     ResourceIdMgr::ResourceId Id;
 409     std::vector<RemoteIndirectStubsInfo> RemoteIndirectStubsInfos;
 410     typedef std::pair<uint16_t, uint16_t> StubKey;
 411     std::vector<StubKey> FreeStubs;
 412     StringMap<std::pair<StubKey, JITSymbolFlags>> StubIndexes;
 413
 414     std::error_code reserveStubs(unsigned NumStubs) {
 415       if (NumStubs <= FreeStubs.size())
 416         return std::error_code();
 417
 418       unsigned NewStubsRequired = NumStubs - FreeStubs.size();
 419       TargetAddress StubBase;
 420       TargetAddress PtrBase;
 421       unsigned NumStubsEmitted;
 422
 423       Remote.emitIndirectStubs(StubBase, PtrBase, NumStubsEmitted, Id,
 424                                NewStubsRequired);
 425
 426       unsigned NewBlockId = RemoteIndirectStubsInfos.size();
 427       RemoteIndirectStubsInfos.push_back(
 428           RemoteIndirectStubsInfo(StubBase, PtrBase, NumStubsEmitted));
 429
 430       for (unsigned I = 0; I < NumStubsEmitted; ++I)
 431         FreeStubs.push_back(std::make_pair(NewBlockId, I));
 432
 433       return std::error_code();
 434     }
 435
 436     std::error_code createStubInternal(StringRef StubName,
 437                                        TargetAddress InitAddr,
 438                                        JITSymbolFlags StubFlags) {
 439       auto Key = FreeStubs.back();
 440       FreeStubs.pop_back();
 441       StubIndexes[StubName] = std::make_pair(Key, StubFlags);
 442       return Remote.writePointer(getPtrAddr(Key), InitAddr);
 443     }
 444
 445     TargetAddress getStubAddr(StubKey K) {
 446       assert(RemoteIndirectStubsInfos[K.first].StubBase != 0 &&
 447              "Missing stub address");
 448       return RemoteIndirectStubsInfos[K.first].StubBase +
 449              K.second * Remote.getIndirectStubSize();
 450     }
 451
 452     TargetAddress getPtrAddr(StubKey K) {
 453       assert(RemoteIndirectStubsInfos[K.first].PtrBase != 0 &&
 454              "Missing pointer address");
 455       return RemoteIndirectStubsInfos[K.first].PtrBase +
 456              K.second * Remote.getPointerSize();
 457     }
 458   };
 459
 460   /// Remote compile callback manager.
 461   class RCCompileCallbackManager : public JITCompileCallbackManager {
 462   public:
 463     RCCompileCallbackManager(TargetAddress ErrorHandlerAddress,
 464                              OrcRemoteTargetClient &Remote)
 465         : JITCompileCallbackManager(ErrorHandlerAddress), Remote(Remote) {
 466       assert(!Remote.CompileCallback && "Compile callback already set");
 467       Remote.CompileCallback = [this](TargetAddress TrampolineAddr) {
 468         return executeCompileCallback(TrampolineAddr);
 469       };
 470       Remote.emitResolverBlock();
 471     }
 472
 473   private:
 474     void grow() {
 475       TargetAddress BlockAddr = 0;
 476       uint32_t NumTrampolines = 0;
 477       auto EC = Remote.emitTrampolineBlock(BlockAddr, NumTrampolines);
 478       assert(!EC && "Failed to create trampolines");
 479
 480       uint32_t TrampolineSize = Remote.getTrampolineSize();
 481       for (unsigned I = 0; I < NumTrampolines; ++I)
 482         this->AvailableTrampolines.push_back(BlockAddr + (I * TrampolineSize));
 483     }
 484
 485     OrcRemoteTargetClient &Remote;
 486   };
 487
 488   /// Create an OrcRemoteTargetClient.
 489   /// Channel is the ChannelT instance to communicate on. It is assumed that
 490   /// the channel is ready to be read from and written to.
 491   static ErrorOr<OrcRemoteTargetClient> Create(ChannelT &Channel) {
 492     std::error_code EC;
 493     OrcRemoteTargetClient H(Channel, EC);
 494     if (EC)
 495       return EC;
 496     return H;
 497   }
 498
 499   /// Call the int(void) function at the given address in the target and return
 500   /// its result.
 501   std::error_code callIntVoid(int &Result, TargetAddress Addr) {
 502     DEBUG(dbgs() << "Calling int(*)(void) " << format("0x%016x", Addr) << "\n");
 503
 504     if (auto EC = call<CallIntVoid>(Channel, Addr))
 505       return EC;
 506
 507     unsigned NextProcId;
 508     if (auto EC = listenForCompileRequests(NextProcId))
 509       return EC;
 510
 511     if (NextProcId != CallIntVoidResponseId)
 512       return orcError(OrcErrorCode::UnexpectedRPCCall);
 513
 514     return handle<CallIntVoidResponse>(Channel, [&](int R) {
 515       Result = R;
 516       DEBUG(dbgs() << "Result: " << R << "\n");
 517       return std::error_code();
 518     });
 519   }
 520
 521   /// Call the int(int, char*[]) function at the given address in the target and
 522   /// return its result.
 523   std::error_code callMain(int &Result, TargetAddress Addr,
 524                            const std::vector<std::string> &Args) {
 525     DEBUG(dbgs() << "Calling int(*)(int, char*[]) " << format("0x%016x", Addr)
 526                  << "\n");
 527
 528     if (auto EC = call<CallMain>(Channel, Addr, Args))
 529       return EC;
 530
 531     unsigned NextProcId;
 532     if (auto EC = listenForCompileRequests(NextProcId))
 533       return EC;
 534
 535     if (NextProcId != CallMainResponseId)
 536       return orcError(OrcErrorCode::UnexpectedRPCCall);
 537
 538     return handle<CallMainResponse>(Channel, [&](int R) {
 539       Result = R;
 540       DEBUG(dbgs() << "Result: " << R << "\n");
 541       return std::error_code();
 542     });
 543   }
 544
 545   /// Call the void() function at the given address in the target and wait for
 546   /// it to finish.
 547   std::error_code callVoidVoid(TargetAddress Addr) {
 548     DEBUG(dbgs() << "Calling void(*)(void) " << format("0x%016x", Addr)
 549                  << "\n");
 550
 551     if (auto EC = call<CallVoidVoid>(Channel, Addr))
 552       return EC;
 553
 554     unsigned NextProcId;
 555     if (auto EC = listenForCompileRequests(NextProcId))
 556       return EC;
 557
 558     if (NextProcId != CallVoidVoidResponseId)
 559       return orcError(OrcErrorCode::UnexpectedRPCCall);
 560
 561     return handle<CallVoidVoidResponse>(Channel, doNothing);
 562   }
 563
 564   /// Create an RCMemoryManager which will allocate its memory on the remote
 565   /// target.
 566   std::error_code
 567   createRemoteMemoryManager(std::unique_ptr<RCMemoryManager> &MM) {
 568     assert(!MM && "MemoryManager should be null before creation.");
 569
 570     auto Id = AllocatorIds.getNext();
 571     if (auto EC = call<CreateRemoteAllocator>(Channel, Id))
 572       return EC;
 573     MM = llvm::make_unique<RCMemoryManager>(*this, Id);
 574     return std::error_code();
 575   }
 576
 577   /// Create an RCIndirectStubsManager that will allocate stubs on the remote
 578   /// target.
 579   std::error_code
 580   createIndirectStubsManager(std::unique_ptr<RCIndirectStubsManager> &I) {
 581     assert(!I && "Indirect stubs manager should be null before creation.");
 582     auto Id = IndirectStubOwnerIds.getNext();
 583     if (auto EC = call<CreateIndirectStubsOwner>(Channel, Id))
 584       return EC;
 585     I = llvm::make_unique<RCIndirectStubsManager>(*this, Id);
 586     return std::error_code();
 587   }
 588
 589   /// Search for symbols in the remote process. Note: This should be used by
 590   /// symbol resolvers *after* they've searched the local symbol table in the
 591   /// JIT stack.
 592   std::error_code getSymbolAddress(TargetAddress &Addr, StringRef Name) {
 593     // Check for an 'out-of-band' error, e.g. from an MM destructor.
 594     if (ExistingError)
 595       return ExistingError;
 596
 597     // Request remote symbol address.
 598     if (auto EC = call<GetSymbolAddress>(Channel, Name))
 599       return EC;
 600
 601     return expect<GetSymbolAddressResponse>(Channel, [&](TargetAddress &A) {
 602       Addr = A;
 603       DEBUG(dbgs() << "Remote address lookup " << Name << " = "
 604                    << format("0x%016x", Addr) << "\n");
 605       return std::error_code();
 606     });
 607   }
 608
 609   /// Get the triple for the remote target.
 610   const std::string &getTargetTriple() const { return RemoteTargetTriple; }
 611
 612   std::error_code terminateSession() { return call<TerminateSession>(Channel); }
 613
 614 private:
 615   OrcRemoteTargetClient(ChannelT &Channel, std::error_code &EC)
 616       : Channel(Channel), RemotePointerSize(0), RemotePageSize(0),
 617         RemoteTrampolineSize(0), RemoteIndirectStubSize(0) {
 618     if ((EC = call<GetRemoteInfo>(Channel)))
 619       return;
 620
 621     EC = expect<GetRemoteInfoResponse>(
 622         Channel, readArgs(RemoteTargetTriple, RemotePointerSize, RemotePageSize,
 623                           RemoteTrampolineSize, RemoteIndirectStubSize));
 624   }
 625
 626   void destroyRemoteAllocator(ResourceIdMgr::ResourceId Id) {
 627     if (auto EC = call<DestroyRemoteAllocator>(Channel, Id)) {
 628       // FIXME: This will be triggered by a removeModuleSet call: Propagate
 629       //        error return up through that.
 630       llvm_unreachable("Failed to destroy remote allocator.");
 631       AllocatorIds.release(Id);
 632     }
 633   }
 634
 635   std::error_code destroyIndirectStubsManager(ResourceIdMgr::ResourceId Id) {
 636     IndirectStubOwnerIds.release(Id);
 637     return call<DestroyIndirectStubsOwner>(Channel, Id);
 638   }
 639
 640   std::error_code emitIndirectStubs(TargetAddress &StubBase,
 641                                     TargetAddress &PtrBase,
 642                                     uint32_t &NumStubsEmitted,
 643                                     ResourceIdMgr::ResourceId Id,
 644                                     uint32_t NumStubsRequired) {
 645     if (auto EC = call<EmitIndirectStubs>(Channel, Id, NumStubsRequired))
 646       return EC;
 647
 648     return expect<EmitIndirectStubsResponse>(
 649         Channel, readArgs(StubBase, PtrBase, NumStubsEmitted));
 650   }
 651
 652   std::error_code emitResolverBlock() {
 653     // Check for an 'out-of-band' error, e.g. from an MM destructor.
 654     if (ExistingError)
 655       return ExistingError;
 656
 657     return call<EmitResolverBlock>(Channel);
 658   }
 659
 660   std::error_code emitTrampolineBlock(TargetAddress &BlockAddr,
 661                                       uint32_t &NumTrampolines) {
 662     // Check for an 'out-of-band' error, e.g. from an MM destructor.
 663     if (ExistingError)
 664       return ExistingError;
 665
 666     if (auto EC = call<EmitTrampolineBlock>(Channel))
 667       return EC;
 668
 669     return expect<EmitTrampolineBlockResponse>(
 670         Channel, [&](TargetAddress BAddr, uint32_t NTrampolines) {
 671           BlockAddr = BAddr;
 672           NumTrampolines = NTrampolines;
 673           return std::error_code();
 674         });
 675   }
 676
 677   uint32_t getIndirectStubSize() const { return RemoteIndirectStubSize; }
 678   uint32_t getPageSize() const { return RemotePageSize; }
 679   uint32_t getPointerSize() const { return RemotePointerSize; }
 680
 681   uint32_t getTrampolineSize() const { return RemoteTrampolineSize; }
 682
 683   std::error_code listenForCompileRequests(uint32_t &NextId) {
 684     // Check for an 'out-of-band' error, e.g. from an MM destructor.
 685     if (ExistingError)
 686       return ExistingError;
 687
 688     if (auto EC = getNextProcId(Channel, NextId))
 689       return EC;
 690
 691     while (NextId == RequestCompileId) {
 692       TargetAddress TrampolineAddr = 0;
 693       if (auto EC = handle<RequestCompile>(Channel, readArgs(TrampolineAddr)))
 694         return EC;
 695
 696       TargetAddress ImplAddr = CompileCallback(TrampolineAddr);
 697       if (auto EC = call<RequestCompileResponse>(Channel, ImplAddr))
 698         return EC;
 699
 700       if (auto EC = getNextProcId(Channel, NextId))
 701         return EC;
 702     }
 703
 704     return std::error_code();
 705   }
 706
 707   std::error_code readMem(char *Dst, TargetAddress Src, uint64_t Size) {
 708     // Check for an 'out-of-band' error, e.g. from an MM destructor.
 709     if (ExistingError)
 710       return ExistingError;
 711
 712     if (auto EC = call<ReadMem>(Channel, Src, Size))
 713       return EC;
 714
 715     if (auto EC = expect<ReadMemResponse>(
 716             Channel, [&]() { return Channel.readBytes(Dst, Size); }))
 717       return EC;
 718
 719     return std::error_code();
 720   }
 721
 722   std::error_code reserveMem(TargetAddress &RemoteAddr,
 723                              ResourceIdMgr::ResourceId Id, uint64_t Size,
 724                              uint32_t Align) {
 725
 726     // Check for an 'out-of-band' error, e.g. from an MM destructor.
 727     if (ExistingError)
 728       return ExistingError;
 729
 730     if (auto EC = call<ReserveMem>(Channel, Id, Size, Align))
 731       return EC;
 732
 733     if (std::error_code EC =
 734             expect<ReserveMemResponse>(Channel, [&](TargetAddress Addr) {
 735               RemoteAddr = Addr;
 736               return std::error_code();
 737             }))
 738       return EC;
 739
 740     return std::error_code();
 741   }
 742
 743   std::error_code setProtections(ResourceIdMgr::ResourceId Id,
 744                                  TargetAddress RemoteSegAddr,
 745                                  unsigned ProtFlags) {
 746     return call<SetProtections>(Channel, Id, RemoteSegAddr, ProtFlags);
 747   }
 748
 749   std::error_code writeMem(TargetAddress Addr, const char *Src, uint64_t Size) {
 750     // Check for an 'out-of-band' error, e.g. from an MM destructor.
 751     if (ExistingError)
 752       return ExistingError;
 753
 754     // Make the send call.
 755     if (auto EC = call<WriteMem>(Channel, Addr, Size))
 756       return EC;
 757
 758     // Follow this up with the section contents.
 759     if (auto EC = Channel.appendBytes(Src, Size))
 760       return EC;
 761
 762     return Channel.send();
 763   }
 764
 765   std::error_code writePointer(TargetAddress Addr, TargetAddress PtrVal) {
 766     // Check for an 'out-of-band' error, e.g. from an MM destructor.
 767     if (ExistingError)
 768       return ExistingError;
 769
 770     return call<WritePtr>(Channel, Addr, PtrVal);
 771   }
 772
 773   static std::error_code doNothing() { return std::error_code(); }
 774
 775   ChannelT &Channel;
 776   std::error_code ExistingError;
 777   std::string RemoteTargetTriple;
 778   uint32_t RemotePointerSize;
 779   uint32_t RemotePageSize;
 780   uint32_t RemoteTrampolineSize;
 781   uint32_t RemoteIndirectStubSize;
 782   ResourceIdMgr AllocatorIds, IndirectStubOwnerIds;
 783   std::function<TargetAddress(TargetAddress)> CompileCallback;
 784 };
 785
 786 } // end namespace remote
 787 } // end namespace orc
 788 } // end namespace llvm
 789
 790 #undef DEBUG_TYPE
 791
 792 #endif