contrib/llvm/tools/lli/RemoteJITUtils.h

   1 //===-- RemoteJITUtils.h - Utilities for remote-JITing with LLI -*- 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 // Utilities for remote-JITing with LLI.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_TOOLS_LLI_REMOTEJITUTILS_H
  15 #define LLVM_TOOLS_LLI_REMOTEJITUTILS_H
  16
  17 #include "llvm/ExecutionEngine/Orc/RPCChannel.h"
  18 #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
  19 #include <mutex>
  20
  21 #if !defined(_MSC_VER) && !defined(__MINGW32__)
  22 #include <unistd.h>
  23 #else
  24 #include <io.h>
  25 #endif
  26
  27 /// RPC channel that reads from and writes from file descriptors.
  28 class FDRPCChannel final : public llvm::orc::remote::RPCChannel {
  29 public:
  30   FDRPCChannel(int InFD, int OutFD) : InFD(InFD), OutFD(OutFD) {}
  31
  32   llvm::Error readBytes(char *Dst, unsigned Size) override {
  33     assert(Dst && "Attempt to read into null.");
  34     ssize_t Completed = 0;
  35     while (Completed < static_cast<ssize_t>(Size)) {
  36       ssize_t Read = ::read(InFD, Dst + Completed, Size - Completed);
  37       if (Read <= 0) {
  38         auto ErrNo = errno;
  39         if (ErrNo == EAGAIN || ErrNo == EINTR)
  40           continue;
  41         else
  42           return llvm::errorCodeToError(
  43                    std::error_code(errno, std::generic_category()));
  44       }
  45       Completed += Read;
  46     }
  47     return llvm::Error::success();
  48   }
  49
  50   llvm::Error appendBytes(const char *Src, unsigned Size) override {
  51     assert(Src && "Attempt to append from null.");
  52     ssize_t Completed = 0;
  53     while (Completed < static_cast<ssize_t>(Size)) {
  54       ssize_t Written = ::write(OutFD, Src + Completed, Size - Completed);
  55       if (Written < 0) {
  56         auto ErrNo = errno;
  57         if (ErrNo == EAGAIN || ErrNo == EINTR)
  58           continue;
  59         else
  60           return llvm::errorCodeToError(
  61                    std::error_code(errno, std::generic_category()));
  62       }
  63       Completed += Written;
  64     }
  65     return llvm::Error::success();
  66   }
  67
  68   llvm::Error send() override { return llvm::Error::success(); }
  69
  70 private:
  71   int InFD, OutFD;
  72 };
  73
  74 // launch the remote process (see lli.cpp) and return a channel to it.
  75 std::unique_ptr<FDRPCChannel> launchRemote();
  76
  77 namespace llvm {
  78
  79 // ForwardingMM - Adapter to connect MCJIT to Orc's Remote memory manager.
  80 class ForwardingMemoryManager : public llvm::RTDyldMemoryManager {
  81 public:
  82   void setMemMgr(std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr) {
  83     this->MemMgr = std::move(MemMgr);
  84   }
  85
  86   void setResolver(std::unique_ptr<RuntimeDyld::SymbolResolver> Resolver) {
  87     this->Resolver = std::move(Resolver);
  88   }
  89
  90   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
  91                                unsigned SectionID,
  92                                StringRef SectionName) override {
  93     return MemMgr->allocateCodeSection(Size, Alignment, SectionID, SectionName);
  94   }
  95
  96   uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
  97                                unsigned SectionID, StringRef SectionName,
  98                                bool IsReadOnly) override {
  99     return MemMgr->allocateDataSection(Size, Alignment, SectionID, SectionName,
 100                                        IsReadOnly);
 101   }
 102
 103   void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
 104                               uintptr_t RODataSize, uint32_t RODataAlign,
 105                               uintptr_t RWDataSize,
 106                               uint32_t RWDataAlign) override {
 107     MemMgr->reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign,
 108                                    RWDataSize, RWDataAlign);
 109   }
 110
 111   bool needsToReserveAllocationSpace() override {
 112     return MemMgr->needsToReserveAllocationSpace();
 113   }
 114
 115   void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr,
 116                         size_t Size) override {
 117     MemMgr->registerEHFrames(Addr, LoadAddr, Size);
 118   }
 119
 120   void deregisterEHFrames(uint8_t *Addr, uint64_t LoadAddr,
 121                           size_t Size) override {
 122     MemMgr->deregisterEHFrames(Addr, LoadAddr, Size);
 123   }
 124
 125   bool finalizeMemory(std::string *ErrMsg = nullptr) override {
 126     return MemMgr->finalizeMemory(ErrMsg);
 127   }
 128
 129   void notifyObjectLoaded(RuntimeDyld &RTDyld,
 130                           const object::ObjectFile &Obj) override {
 131     MemMgr->notifyObjectLoaded(RTDyld, Obj);
 132   }
 133
 134   // Don't hide the sibling notifyObjectLoaded from RTDyldMemoryManager.
 135   using RTDyldMemoryManager::notifyObjectLoaded;
 136
 137   RuntimeDyld::SymbolInfo findSymbol(const std::string &Name) override {
 138     return Resolver->findSymbol(Name);
 139   }
 140
 141   RuntimeDyld::SymbolInfo
 142   findSymbolInLogicalDylib(const std::string &Name) override {
 143     return Resolver->findSymbolInLogicalDylib(Name);
 144   }
 145
 146 private:
 147   std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr;
 148   std::unique_ptr<RuntimeDyld::SymbolResolver> Resolver;
 149 };
 150 }
 151
 152 #endif