Home | History | Annotate | Download | only in lli 
      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
    153