LCOV - code coverage report
Current view: top level - include/llvm/ExecutionEngine/Orc - OrcRemoteTargetServer.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 89 180 49.4 %
Date: 2017-09-14 15:23:50 Functions: 15 26 57.7 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "llvm/ExecutionEngine/JITSymbol.h"
      19             : #include "llvm/ExecutionEngine/Orc/OrcError.h"
      20             : #include "llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h"
      21             : #include "llvm/Support/Debug.h"
      22             : #include "llvm/Support/Error.h"
      23             : #include "llvm/Support/Format.h"
      24             : #include "llvm/Support/Host.h"
      25             : #include "llvm/Support/Memory.h"
      26             : #include "llvm/Support/Process.h"
      27             : #include "llvm/Support/raw_ostream.h"
      28             : #include <algorithm>
      29             : #include <cassert>
      30             : #include <cstddef>
      31             : #include <cstdint>
      32             : #include <functional>
      33             : #include <map>
      34             : #include <memory>
      35             : #include <string>
      36             : #include <system_error>
      37             : #include <tuple>
      38             : #include <type_traits>
      39             : #include <vector>
      40             : 
      41             : #define DEBUG_TYPE "orc-remote"
      42             : 
      43             : namespace llvm {
      44             : namespace orc {
      45             : namespace remote {
      46             : 
      47             : template <typename ChannelT, typename TargetT>
      48         192 : class OrcRemoteTargetServer
      49             :     : public rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel> {
      50             : public:
      51             :   using SymbolLookupFtor =
      52             :       std::function<JITTargetAddress(const std::string &Name)>;
      53             : 
      54             :   using EHFrameRegistrationFtor =
      55             :       std::function<void(uint8_t *Addr, uint32_t Size)>;
      56             : 
      57          24 :   OrcRemoteTargetServer(ChannelT &Channel, SymbolLookupFtor SymbolLookup,
      58             :                         EHFrameRegistrationFtor EHFramesRegister,
      59             :                         EHFrameRegistrationFtor EHFramesDeregister)
      60             :       : rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel>(Channel, true),
      61          24 :         SymbolLookup(std::move(SymbolLookup)),
      62          24 :         EHFramesRegister(std::move(EHFramesRegister)),
      63         216 :         EHFramesDeregister(std::move(EHFramesDeregister)) {
      64             :     using ThisT = typename std::remove_reference<decltype(*this)>::type;
      65          48 :     addHandler<exec::CallIntVoid>(*this, &ThisT::handleCallIntVoid);
      66          48 :     addHandler<exec::CallMain>(*this, &ThisT::handleCallMain);
      67          48 :     addHandler<exec::CallVoidVoid>(*this, &ThisT::handleCallVoidVoid);
      68          48 :     addHandler<mem::CreateRemoteAllocator>(*this,
      69             :                                            &ThisT::handleCreateRemoteAllocator);
      70          48 :     addHandler<mem::DestroyRemoteAllocator>(
      71             :         *this, &ThisT::handleDestroyRemoteAllocator);
      72          48 :     addHandler<mem::ReadMem>(*this, &ThisT::handleReadMem);
      73          48 :     addHandler<mem::ReserveMem>(*this, &ThisT::handleReserveMem);
      74          48 :     addHandler<mem::SetProtections>(*this, &ThisT::handleSetProtections);
      75          48 :     addHandler<mem::WriteMem>(*this, &ThisT::handleWriteMem);
      76          48 :     addHandler<mem::WritePtr>(*this, &ThisT::handleWritePtr);
      77          48 :     addHandler<eh::RegisterEHFrames>(*this, &ThisT::handleRegisterEHFrames);
      78          48 :     addHandler<eh::DeregisterEHFrames>(*this, &ThisT::handleDeregisterEHFrames);
      79          48 :     addHandler<stubs::CreateIndirectStubsOwner>(
      80             :         *this, &ThisT::handleCreateIndirectStubsOwner);
      81          48 :     addHandler<stubs::DestroyIndirectStubsOwner>(
      82             :         *this, &ThisT::handleDestroyIndirectStubsOwner);
      83          48 :     addHandler<stubs::EmitIndirectStubs>(*this,
      84             :                                          &ThisT::handleEmitIndirectStubs);
      85          48 :     addHandler<stubs::EmitResolverBlock>(*this,
      86             :                                          &ThisT::handleEmitResolverBlock);
      87          48 :     addHandler<stubs::EmitTrampolineBlock>(*this,
      88             :                                            &ThisT::handleEmitTrampolineBlock);
      89          48 :     addHandler<utils::GetSymbolAddress>(*this, &ThisT::handleGetSymbolAddress);
      90          48 :     addHandler<utils::GetRemoteInfo>(*this, &ThisT::handleGetRemoteInfo);
      91          48 :     addHandler<utils::TerminateSession>(*this, &ThisT::handleTerminateSession);
      92          24 :   }
      93             : 
      94             :   // FIXME: Remove move/copy ops once MSVC supports synthesizing move ops.
      95             :   OrcRemoteTargetServer(const OrcRemoteTargetServer &) = delete;
      96             :   OrcRemoteTargetServer &operator=(const OrcRemoteTargetServer &) = delete;
      97             : 
      98             :   OrcRemoteTargetServer(OrcRemoteTargetServer &&Other) = default;
      99             :   OrcRemoteTargetServer &operator=(OrcRemoteTargetServer &&) = delete;
     100             : 
     101             :   Expected<JITTargetAddress> requestCompile(JITTargetAddress TrampolineAddr) {
     102           0 :     return callB<utils::RequestCompile>(TrampolineAddr);
     103             :   }
     104             : 
     105             :   bool receivedTerminate() const { return TerminateFlag; }
     106             : 
     107             : private:
     108             :   struct Allocator {
     109          96 :     Allocator() = default;
     110             :     Allocator(Allocator &&Other) : Allocs(std::move(Other.Allocs)) {}
     111             : 
     112             :     Allocator &operator=(Allocator &&Other) {
     113          48 :       Allocs = std::move(Other.Allocs);
     114             :       return *this;
     115             :     }
     116             : 
     117          48 :     ~Allocator() {
     118         202 :       for (auto &Alloc : Allocs)
     119          58 :         sys::Memory::releaseMappedMemory(Alloc.second);
     120          96 :     }
     121             : 
     122          58 :     Error allocate(void *&Addr, size_t Size, uint32_t Align) {
     123          58 :       std::error_code EC;
     124          58 :       sys::MemoryBlock MB = sys::Memory::allocateMappedMemory(
     125             :           Size, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);
     126          58 :       if (EC)
     127           0 :         return errorCodeToError(EC);
     128             : 
     129          58 :       Addr = MB.base();
     130             :       assert(Allocs.find(MB.base()) == Allocs.end() && "Duplicate alloc");
     131          58 :       Allocs[MB.base()] = std::move(MB);
     132         174 :       return Error::success();
     133             :     }
     134             : 
     135          58 :     Error setProtections(void *block, unsigned Flags) {
     136         116 :       auto I = Allocs.find(block);
     137         116 :       if (I == Allocs.end())
     138           0 :         return errorCodeToError(orcError(OrcErrorCode::RemoteMProtectAddrUnrecognized));
     139             :       return errorCodeToError(
     140          58 :           sys::Memory::protectMappedMemory(I->second, Flags));
     141             :     }
     142             : 
     143             :   private:
     144             :     std::map<void *, sys::MemoryBlock> Allocs;
     145             :   };
     146             : 
     147             :   static Error doNothing() { return Error::success(); }
     148             : 
     149           0 :   static JITTargetAddress reenter(void *JITTargetAddr, void *TrampolineAddr) {
     150           0 :     auto T = static_cast<OrcRemoteTargetServer *>(JITTargetAddr);
     151           0 :     auto AddrOrErr = T->requestCompile(static_cast<JITTargetAddress>(
     152             :         reinterpret_cast<uintptr_t>(TrampolineAddr)));
     153             :     // FIXME: Allow customizable failure substitution functions.
     154             :     assert(AddrOrErr && "Compile request failed");
     155           0 :     return *AddrOrErr;
     156             :   }
     157             : 
     158          24 :   Expected<int32_t> handleCallIntVoid(JITTargetAddress Addr) {
     159             :     using IntVoidFnTy = int (*)();
     160             : 
     161          24 :     IntVoidFnTy Fn =
     162             :         reinterpret_cast<IntVoidFnTy>(static_cast<uintptr_t>(Addr));
     163             : 
     164             :     DEBUG(dbgs() << "  Calling " << format("0x%016x", Addr) << "\n");
     165          24 :     int Result = Fn();
     166             :     DEBUG(dbgs() << "  Result = " << Result << "\n");
     167             : 
     168          24 :     return Result;
     169             :   }
     170             : 
     171           0 :   Expected<int32_t> handleCallMain(JITTargetAddress Addr,
     172             :                                    std::vector<std::string> Args) {
     173             :     using MainFnTy = int (*)(int, const char *[]);
     174             : 
     175           0 :     MainFnTy Fn = reinterpret_cast<MainFnTy>(static_cast<uintptr_t>(Addr));
     176           0 :     int ArgC = Args.size() + 1;
     177           0 :     int Idx = 1;
     178           0 :     std::unique_ptr<const char *[]> ArgV(new const char *[ArgC + 1]);
     179           0 :     ArgV[0] = "<jit process>";
     180           0 :     for (auto &Arg : Args)
     181           0 :       ArgV[Idx++] = Arg.c_str();
     182           0 :     ArgV[ArgC] = 0;
     183             :     DEBUG(
     184             :       for (int Idx = 0; Idx < ArgC; ++Idx) {
     185             :         llvm::dbgs() << "Arg " << Idx << ": " << ArgV[Idx] << "\n";
     186             :       }
     187             :     );
     188             : 
     189             :     DEBUG(dbgs() << "  Calling " << format("0x%016x", Addr) << "\n");
     190           0 :     int Result = Fn(ArgC, ArgV.get());
     191             :     DEBUG(dbgs() << "  Result = " << Result << "\n");
     192             : 
     193           0 :     return Result;
     194             :   }
     195             : 
     196           0 :   Error handleCallVoidVoid(JITTargetAddress Addr) {
     197             :     using VoidVoidFnTy = void (*)();
     198             : 
     199           0 :     VoidVoidFnTy Fn =
     200             :         reinterpret_cast<VoidVoidFnTy>(static_cast<uintptr_t>(Addr));
     201             : 
     202             :     DEBUG(dbgs() << "  Calling " << format("0x%016x", Addr) << "\n");
     203           0 :     Fn();
     204             :     DEBUG(dbgs() << "  Complete.\n");
     205             : 
     206           0 :     return Error::success();
     207             :   }
     208             : 
     209          24 :   Error handleCreateRemoteAllocator(ResourceIdMgr::ResourceId Id) {
     210          48 :     auto I = Allocators.find(Id);
     211          48 :     if (I != Allocators.end())
     212             :       return errorCodeToError(
     213           0 :                orcError(OrcErrorCode::RemoteAllocatorIdAlreadyInUse));
     214             :     DEBUG(dbgs() << "  Created allocator " << Id << "\n");
     215          72 :     Allocators[Id] = Allocator();
     216          72 :     return Error::success();
     217             :   }
     218             : 
     219           0 :   Error handleCreateIndirectStubsOwner(ResourceIdMgr::ResourceId Id) {
     220           0 :     auto I = IndirectStubsOwners.find(Id);
     221           0 :     if (I != IndirectStubsOwners.end())
     222             :       return errorCodeToError(
     223           0 :                orcError(OrcErrorCode::RemoteIndirectStubsOwnerIdAlreadyInUse));
     224             :     DEBUG(dbgs() << "  Create indirect stubs owner " << Id << "\n");
     225           0 :     IndirectStubsOwners[Id] = ISBlockOwnerList();
     226           0 :     return Error::success();
     227             :   }
     228             : 
     229           0 :   Error handleDeregisterEHFrames(JITTargetAddress TAddr, uint32_t Size) {
     230           0 :     uint8_t *Addr = reinterpret_cast<uint8_t *>(static_cast<uintptr_t>(TAddr));
     231             :     DEBUG(dbgs() << "  Registering EH frames at " << format("0x%016x", TAddr)
     232             :                  << ", Size = " << Size << " bytes\n");
     233           0 :     EHFramesDeregister(Addr, Size);
     234           0 :     return Error::success();
     235             :   }
     236             : 
     237          24 :   Error handleDestroyRemoteAllocator(ResourceIdMgr::ResourceId Id) {
     238          48 :     auto I = Allocators.find(Id);
     239          48 :     if (I == Allocators.end())
     240             :       return errorCodeToError(
     241           0 :                orcError(OrcErrorCode::RemoteAllocatorDoesNotExist));
     242          48 :     Allocators.erase(I);
     243             :     DEBUG(dbgs() << "  Destroyed allocator " << Id << "\n");
     244          72 :     return Error::success();
     245             :   }
     246             : 
     247           0 :   Error handleDestroyIndirectStubsOwner(ResourceIdMgr::ResourceId Id) {
     248           0 :     auto I = IndirectStubsOwners.find(Id);
     249           0 :     if (I == IndirectStubsOwners.end())
     250             :       return errorCodeToError(
     251           0 :                orcError(OrcErrorCode::RemoteIndirectStubsOwnerDoesNotExist));
     252           0 :     IndirectStubsOwners.erase(I);
     253           0 :     return Error::success();
     254             :   }
     255             : 
     256             :   Expected<std::tuple<JITTargetAddress, JITTargetAddress, uint32_t>>
     257           0 :   handleEmitIndirectStubs(ResourceIdMgr::ResourceId Id,
     258             :                           uint32_t NumStubsRequired) {
     259             :     DEBUG(dbgs() << "  ISMgr " << Id << " request " << NumStubsRequired
     260             :                  << " stubs.\n");
     261             : 
     262           0 :     auto StubOwnerItr = IndirectStubsOwners.find(Id);
     263           0 :     if (StubOwnerItr == IndirectStubsOwners.end())
     264             :       return errorCodeToError(
     265           0 :                orcError(OrcErrorCode::RemoteIndirectStubsOwnerDoesNotExist));
     266             : 
     267           0 :     typename TargetT::IndirectStubsInfo IS;
     268           0 :     if (auto Err =
     269             :             TargetT::emitIndirectStubsBlock(IS, NumStubsRequired, nullptr))
     270           0 :       return std::move(Err);
     271             : 
     272           0 :     JITTargetAddress StubsBase = static_cast<JITTargetAddress>(
     273           0 :         reinterpret_cast<uintptr_t>(IS.getStub(0)));
     274           0 :     JITTargetAddress PtrsBase = static_cast<JITTargetAddress>(
     275           0 :         reinterpret_cast<uintptr_t>(IS.getPtr(0)));
     276           0 :     uint32_t NumStubsEmitted = IS.getNumStubs();
     277             : 
     278           0 :     auto &BlockList = StubOwnerItr->second;
     279           0 :     BlockList.push_back(std::move(IS));
     280             : 
     281           0 :     return std::make_tuple(StubsBase, PtrsBase, NumStubsEmitted);
     282             :   }
     283             : 
     284           0 :   Error handleEmitResolverBlock() {
     285           0 :     std::error_code EC;
     286           0 :     ResolverBlock = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
     287             :         TargetT::ResolverCodeSize, nullptr,
     288             :         sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
     289           0 :     if (EC)
     290           0 :       return errorCodeToError(EC);
     291             : 
     292           0 :     TargetT::writeResolverCode(static_cast<uint8_t *>(ResolverBlock.base()),
     293             :                                &reenter, this);
     294             : 
     295             :     return errorCodeToError(sys::Memory::protectMappedMemory(
     296           0 :         ResolverBlock.getMemoryBlock(),
     297           0 :         sys::Memory::MF_READ | sys::Memory::MF_EXEC));
     298             :   }
     299             : 
     300           0 :   Expected<std::tuple<JITTargetAddress, uint32_t>> handleEmitTrampolineBlock() {
     301           0 :     std::error_code EC;
     302           0 :     auto TrampolineBlock =
     303             :         sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
     304           0 :             sys::Process::getPageSize(), nullptr,
     305             :             sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
     306           0 :     if (EC)
     307           0 :       return errorCodeToError(EC);
     308             : 
     309           0 :     uint32_t NumTrampolines =
     310           0 :         (sys::Process::getPageSize() - TargetT::PointerSize) /
     311             :         TargetT::TrampolineSize;
     312             : 
     313           0 :     uint8_t *TrampolineMem = static_cast<uint8_t *>(TrampolineBlock.base());
     314           0 :     TargetT::writeTrampolines(TrampolineMem, ResolverBlock.base(),
     315             :                               NumTrampolines);
     316             : 
     317           0 :     EC = sys::Memory::protectMappedMemory(TrampolineBlock.getMemoryBlock(),
     318             :                                           sys::Memory::MF_READ |
     319             :                                               sys::Memory::MF_EXEC);
     320             : 
     321           0 :     TrampolineBlocks.push_back(std::move(TrampolineBlock));
     322             : 
     323           0 :     auto TrampolineBaseAddr = static_cast<JITTargetAddress>(
     324             :         reinterpret_cast<uintptr_t>(TrampolineMem));
     325             : 
     326           0 :     return std::make_tuple(TrampolineBaseAddr, NumTrampolines);
     327             :   }
     328             : 
     329          20 :   Expected<JITTargetAddress> handleGetSymbolAddress(const std::string &Name) {
     330          40 :     JITTargetAddress Addr = SymbolLookup(Name);
     331             :     DEBUG(dbgs() << "  Symbol '" << Name << "' =  " << format("0x%016x", Addr)
     332             :                  << "\n");
     333          20 :     return Addr;
     334             :   }
     335             : 
     336             :   Expected<std::tuple<std::string, uint32_t, uint32_t, uint32_t, uint32_t>>
     337          24 :   handleGetRemoteInfo() {
     338          48 :     std::string ProcessTriple = sys::getProcessTriple();
     339          24 :     uint32_t PointerSize = TargetT::PointerSize;
     340          24 :     uint32_t PageSize = sys::Process::getPageSize();
     341          24 :     uint32_t TrampolineSize = TargetT::TrampolineSize;
     342          24 :     uint32_t IndirectStubSize = TargetT::IndirectStubsInfo::StubSize;
     343             :     DEBUG(dbgs() << "  Remote info:\n"
     344             :                  << "    triple             = '" << ProcessTriple << "'\n"
     345             :                  << "    pointer size       = " << PointerSize << "\n"
     346             :                  << "    page size          = " << PageSize << "\n"
     347             :                  << "    trampoline size    = " << TrampolineSize << "\n"
     348             :                  << "    indirect stub size = " << IndirectStubSize << "\n");
     349             :     return std::make_tuple(ProcessTriple, PointerSize, PageSize, TrampolineSize,
     350         120 :                            IndirectStubSize);
     351             :   }
     352             : 
     353           0 :   Expected<std::vector<uint8_t>> handleReadMem(JITTargetAddress RSrc,
     354             :                                                uint64_t Size) {
     355           0 :     uint8_t *Src = reinterpret_cast<uint8_t *>(static_cast<uintptr_t>(RSrc));
     356             : 
     357             :     DEBUG(dbgs() << "  Reading " << Size << " bytes from "
     358             :                  << format("0x%016x", RSrc) << "\n");
     359             : 
     360           0 :     std::vector<uint8_t> Buffer;
     361           0 :     Buffer.resize(Size);
     362           0 :     for (uint8_t *P = Src; Size != 0; --Size)
     363           0 :       Buffer.push_back(*P++);
     364             : 
     365           0 :     return Buffer;
     366             :   }
     367             : 
     368           5 :   Error handleRegisterEHFrames(JITTargetAddress TAddr, uint32_t Size) {
     369           5 :     uint8_t *Addr = reinterpret_cast<uint8_t *>(static_cast<uintptr_t>(TAddr));
     370             :     DEBUG(dbgs() << "  Registering EH frames at " << format("0x%016x", TAddr)
     371             :                  << ", Size = " << Size << " bytes\n");
     372          10 :     EHFramesRegister(Addr, Size);
     373          15 :     return Error::success();
     374             :   }
     375             : 
     376          58 :   Expected<JITTargetAddress> handleReserveMem(ResourceIdMgr::ResourceId Id,
     377             :                                               uint64_t Size, uint32_t Align) {
     378         116 :     auto I = Allocators.find(Id);
     379         116 :     if (I == Allocators.end())
     380             :       return errorCodeToError(
     381           0 :                orcError(OrcErrorCode::RemoteAllocatorDoesNotExist));
     382          58 :     auto &Allocator = I->second;
     383          58 :     void *LocalAllocAddr = nullptr;
     384         174 :     if (auto Err = Allocator.allocate(LocalAllocAddr, Size, Align))
     385           0 :       return std::move(Err);
     386             : 
     387             :     DEBUG(dbgs() << "  Allocator " << Id << " reserved " << LocalAllocAddr
     388             :                  << " (" << Size << " bytes, alignment " << Align << ")\n");
     389             : 
     390          58 :     JITTargetAddress AllocAddr = static_cast<JITTargetAddress>(
     391             :         reinterpret_cast<uintptr_t>(LocalAllocAddr));
     392             : 
     393             :     return AllocAddr;
     394             :   }
     395             : 
     396          58 :   Error handleSetProtections(ResourceIdMgr::ResourceId Id,
     397             :                              JITTargetAddress Addr, uint32_t Flags) {
     398         116 :     auto I = Allocators.find(Id);
     399         116 :     if (I == Allocators.end())
     400             :       return errorCodeToError(
     401           0 :                orcError(OrcErrorCode::RemoteAllocatorDoesNotExist));
     402          58 :     auto &Allocator = I->second;
     403          58 :     void *LocalAddr = reinterpret_cast<void *>(static_cast<uintptr_t>(Addr));
     404             :     DEBUG(dbgs() << "  Allocator " << Id << " set permissions on " << LocalAddr
     405             :                  << " to " << (Flags & sys::Memory::MF_READ ? 'R' : '-')
     406             :                  << (Flags & sys::Memory::MF_WRITE ? 'W' : '-')
     407             :                  << (Flags & sys::Memory::MF_EXEC ? 'X' : '-') << "\n");
     408          58 :     return Allocator.setProtections(LocalAddr, Flags);
     409             :   }
     410             : 
     411          24 :   Error handleTerminateSession() {
     412          24 :     TerminateFlag = true;
     413          72 :     return Error::success();
     414             :   }
     415             : 
     416          64 :   Error handleWriteMem(DirectBufferWriter DBW) {
     417             :     DEBUG(dbgs() << "  Writing " << DBW.getSize() << " bytes to "
     418             :                  << format("0x%016x", DBW.getDst()) << "\n");
     419         192 :     return Error::success();
     420             :   }
     421             : 
     422           0 :   Error handleWritePtr(JITTargetAddress Addr, JITTargetAddress PtrVal) {
     423             :     DEBUG(dbgs() << "  Writing pointer *" << format("0x%016x", Addr) << " = "
     424             :                  << format("0x%016x", PtrVal) << "\n");
     425           0 :     uintptr_t *Ptr =
     426             :         reinterpret_cast<uintptr_t *>(static_cast<uintptr_t>(Addr));
     427           0 :     *Ptr = static_cast<uintptr_t>(PtrVal);
     428           0 :     return Error::success();
     429             :   }
     430             : 
     431             :   SymbolLookupFtor SymbolLookup;
     432             :   EHFrameRegistrationFtor EHFramesRegister, EHFramesDeregister;
     433             :   std::map<ResourceIdMgr::ResourceId, Allocator> Allocators;
     434             :   using ISBlockOwnerList = std::vector<typename TargetT::IndirectStubsInfo>;
     435             :   std::map<ResourceIdMgr::ResourceId, ISBlockOwnerList> IndirectStubsOwners;
     436             :   sys::OwningMemoryBlock ResolverBlock;
     437             :   std::vector<sys::OwningMemoryBlock> TrampolineBlocks;
     438             :   bool TerminateFlag = false;
     439             : };
     440             : 
     441             : } // end namespace remote
     442             : } // end namespace orc
     443             : } // end namespace llvm
     444             : 
     445             : #undef DEBUG_TYPE
     446             : 
     447             : #endif // LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETSERVER_H

Generated by: LCOV version 1.13