<div dir="ltr"><br><div class="gmail_extra"><br><div class="gmail_quote">On Fri, Jan 15, 2016 at 8:33 AM, Aaron Ballman via llvm-commits <span dir="ltr"><<a href="mailto:llvm-commits@lists.llvm.org" target="_blank">llvm-commits@lists.llvm.org</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div class="HOEnZb"><div class="h5">On Sun, Jan 10, 2016 at 8:40 PM, Lang Hames via llvm-commits<br>
<<a href="mailto:llvm-commits@lists.llvm.org">llvm-commits@lists.llvm.org</a>> wrote:<br>
> Author: lhames<br>
> Date: Sun Jan 10 19:40:11 2016<br>
> New Revision: 257305<br>
><br>
> URL: <a href="http://llvm.org/viewvc/llvm-project?rev=257305&view=rev" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project?rev=257305&view=rev</a><br>
> Log:<br>
> [Orc] Add support for remote JITing to the ORC API.<br>
><br>
> This patch adds utilities to ORC for managing a remote JIT target. It consists<br>
> of:<br>
><br>
> 1. A very primitive RPC system for making calls over a byte-stream. See<br>
> RPCChannel.h, RPCUtils.h.<br>
><br>
> 2. An RPC API defined in the above system for managing memory, looking up<br>
> symbols, creating stubs, etc. on a remote target. See OrcRemoteTargetRPCAPI.h.<br>
><br>
> 3. An interface for creating high-level JIT components (memory managers,<br>
> callback managers, stub managers, etc.) that operate over the RPC API. See<br>
> OrcRemoteTargetClient.h.<br>
><br>
> 4. A helper class for building servers that can handle the RPC calls. See<br>
> OrcRemoteTargetServer.h.<br>
><br>
> The system is designed to work neatly with the existing ORC components and<br>
> functionality. In particular, the ORC callback API (and consequently the<br>
> CompileOnDemandLayer) is supported, enabling lazy compilation of remote code.<br>
><br>
> Assuming this doesn't trigger any builder failures, a follow-up patch will be<br>
> committed which tests these utilities by using them to replace LLI's existing<br>
> remote-JITing demo code.<br>
><br>
><br>
> Added:<br>
> llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h<br>
> llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h<br>
> llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h<br>
> llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCChannel.h<br>
> llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h<br>
> llvm/trunk/lib/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.cpp<br>
> llvm/trunk/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp<br>
> Modified:<br>
> llvm/trunk/lib/ExecutionEngine/Orc/CMakeLists.txt<br>
> llvm/trunk/unittests/ExecutionEngine/Orc/CMakeLists.txt<br>
><br>
> Added: llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h?rev=257305&view=auto" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h?rev=257305&view=auto</a><br>
> ==============================================================================<br>
> --- llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h (added)<br>
> +++ llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h Sun Jan 10 19:40:11 2016<br>
> @@ -0,0 +1,743 @@<br>
> +//===---- OrcRemoteTargetClient.h - Orc Remote-target Client ----*- C++ -*-===//<br>
> +//<br>
> +// The LLVM Compiler Infrastructure<br>
> +//<br>
> +// This file is distributed under the University of Illinois Open Source<br>
> +// License. See LICENSE.TXT for details.<br>
> +//<br>
> +//===----------------------------------------------------------------------===//<br>
> +//<br>
> +// This file defines the OrcRemoteTargetClient class and helpers. This class<br>
> +// can be used to communicate over an RPCChannel with an OrcRemoteTargetServer<br>
> +// instance to support remote-JITing.<br>
> +//<br>
> +//===----------------------------------------------------------------------===//<br>
> +<br>
> +#ifndef LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETCLIENT_H<br>
> +#define LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETCLIENT_H<br>
> +<br>
> +#include "OrcRemoteTargetRPCAPI.h"<br>
> +<br>
> +#define DEBUG_TYPE "orc-remote"<br>
> +<br>
> +namespace llvm {<br>
> +namespace orc {<br>
> +namespace remote {<br>
> +<br>
> +/// This class provides utilities (including memory manager, indirect stubs<br>
> +/// manager, and compile callback manager types) that support remote JITing<br>
> +/// in ORC.<br>
> +///<br>
> +/// Each of the utility classes talks to a JIT server (an instance of the<br>
> +/// OrcRemoteTargetServer class) via an RPC system (see RPCUtils.h) to carry out<br>
> +/// its actions.<br>
> +template <typename ChannelT><br>
> +class OrcRemoteTargetClient : public OrcRemoteTargetRPCAPI {<br>
> +public:<br>
> + /// Remote memory manager.<br>
> + class RCMemoryManager : public RuntimeDyld::MemoryManager {<br>
> + public:<br>
> + RCMemoryManager(OrcRemoteTargetClient &Client, ResourceIdMgr::ResourceId Id)<br>
> + : Client(Client), Id(Id) {<br>
> + DEBUG(dbgs() << "Created remote allocator " << Id << "\n");<br>
> + }<br>
> +<br>
> + ~RCMemoryManager() {<br>
> + Client.destroyRemoteAllocator(Id);<br>
> + DEBUG(dbgs() << "Destroyed remote allocator " << Id << "\n");<br>
> + }<br>
> +<br>
> + uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,<br>
> + unsigned SectionID,<br>
> + StringRef SectionName) override {<br>
> + Unmapped.back().CodeAllocs.emplace_back(Size, Alignment);<br>
> + uint8_t *Alloc = reinterpret_cast<uint8_t *>(<br>
> + Unmapped.back().CodeAllocs.back().getLocalAddress());<br>
> + DEBUG(dbgs() << "Allocator " << Id << " allocated code for "<br>
> + << SectionName << ": " << Alloc << " (" << Size<br>
> + << " bytes, alignment " << Alignment << ")\n");<br>
> + return Alloc;<br>
> + }<br>
> +<br>
> + uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,<br>
> + unsigned SectionID, StringRef SectionName,<br>
> + bool IsReadOnly) override {<br>
> + if (IsReadOnly) {<br>
> + Unmapped.back().RODataAllocs.emplace_back(Size, Alignment);<br>
> + uint8_t *Alloc = reinterpret_cast<uint8_t *>(<br>
> + Unmapped.back().RODataAllocs.back().getLocalAddress());<br>
> + DEBUG(dbgs() << "Allocator " << Id << " allocated ro-data for "<br>
> + << SectionName << ": " << Alloc << " (" << Size<br>
> + << " bytes, alignment " << Alignment << ")\n");<br>
> + return Alloc;<br>
> + } // else...<br>
> +<br>
> + Unmapped.back().RWDataAllocs.emplace_back(Size, Alignment);<br>
> + uint8_t *Alloc = reinterpret_cast<uint8_t *>(<br>
> + Unmapped.back().RWDataAllocs.back().getLocalAddress());<br>
> + DEBUG(dbgs() << "Allocator " << Id << " allocated rw-data for "<br>
> + << SectionName << ": " << Alloc << " (" << Size<br>
> + << " bytes, alignment " << Alignment << "\n");<br>
> + return Alloc;<br>
> + }<br>
> +<br>
> + void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,<br>
> + uintptr_t RODataSize, uint32_t RODataAlign,<br>
> + uintptr_t RWDataSize,<br>
> + uint32_t RWDataAlign) override {<br>
> + Unmapped.push_back(ObjectAllocs());<br>
> +<br>
> + DEBUG(dbgs() << "Allocator " << Id << " reserved:\n");<br>
> +<br>
> + if (CodeSize != 0) {<br>
> + if (auto EC = Client.reserveMem(Unmapped.back().RemoteCodeAddr, Id,<br>
> + CodeSize, CodeAlign)) {<br>
> + // FIXME; Add error to poll.<br>
> + llvm_unreachable("Failed reserving remote memory.");<br>
> + }<br>
> + DEBUG(dbgs() << " code: "<br>
> + << format("0x%016x", Unmapped.back().RemoteCodeAddr)<br>
> + << " (" << CodeSize << " bytes, alignment " << CodeAlign<br>
> + << ")\n");<br>
> + }<br>
> +<br>
> + if (RODataSize != 0) {<br>
> + if (auto EC = Client.reserveMem(Unmapped.back().RemoteRODataAddr, Id,<br>
> + RODataSize, RODataAlign)) {<br>
> + // FIXME; Add error to poll.<br>
> + llvm_unreachable("Failed reserving remote memory.");<br>
> + }<br>
> + DEBUG(dbgs() << " ro-data: "<br>
> + << format("0x%016x", Unmapped.back().RemoteRODataAddr)<br>
> + << " (" << RODataSize << " bytes, alignment "<br>
> + << RODataAlign << ")\n");<br>
> + }<br>
> +<br>
> + if (RWDataSize != 0) {<br>
> + if (auto EC = Client.reserveMem(Unmapped.back().RemoteRWDataAddr, Id,<br>
> + RWDataSize, RWDataAlign)) {<br>
> + // FIXME; Add error to poll.<br>
> + llvm_unreachable("Failed reserving remote memory.");<br>
> + }<br>
> + DEBUG(dbgs() << " rw-data: "<br>
> + << format("0x%016x", Unmapped.back().RemoteRWDataAddr)<br>
> + << " (" << RWDataSize << " bytes, alignment "<br>
> + << RWDataAlign << ")\n");<br>
> + }<br>
> + }<br>
> +<br>
> + bool needsToReserveAllocationSpace() override { return true; }<br>
> +<br>
> + void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr,<br>
> + size_t Size) override {}<br>
> +<br>
> + void deregisterEHFrames(uint8_t *addr, uint64_t LoadAddr,<br>
> + size_t Size) override {}<br>
> +<br>
> + void notifyObjectLoaded(RuntimeDyld &Dyld,<br>
> + const object::ObjectFile &Obj) override {<br>
> + DEBUG(dbgs() << "Allocator " << Id << " applied mappings:\n");<br>
> + for (auto &ObjAllocs : Unmapped) {<br>
> + {<br>
> + TargetAddress NextCodeAddr = ObjAllocs.RemoteCodeAddr;<br>
> + for (auto &Alloc : ObjAllocs.CodeAllocs) {<br>
> + NextCodeAddr = RoundUpToAlignment(NextCodeAddr, Alloc.getAlign());<br>
> + Dyld.mapSectionAddress(Alloc.getLocalAddress(), NextCodeAddr);<br>
> + DEBUG(dbgs() << " code: "<br>
> + << static_cast<void *>(Alloc.getLocalAddress())<br>
> + << " -> " << format("0x%016x", NextCodeAddr) << "\n");<br>
> + Alloc.setRemoteAddress(NextCodeAddr);<br>
> + NextCodeAddr += Alloc.getSize();<br>
> + }<br>
> + }<br>
> + {<br>
> + TargetAddress NextRODataAddr = ObjAllocs.RemoteRODataAddr;<br>
> + for (auto &Alloc : ObjAllocs.RODataAllocs) {<br>
> + NextRODataAddr =<br>
> + RoundUpToAlignment(NextRODataAddr, Alloc.getAlign());<br>
> + Dyld.mapSectionAddress(Alloc.getLocalAddress(), NextRODataAddr);<br>
> + DEBUG(dbgs() << " ro-data: "<br>
> + << static_cast<void *>(Alloc.getLocalAddress())<br>
> + << " -> " << format("0x%016x", NextRODataAddr)<br>
> + << "\n");<br>
> + Alloc.setRemoteAddress(NextRODataAddr);<br>
> + NextRODataAddr += Alloc.getSize();<br>
> + }<br>
> + }<br>
> + {<br>
> + TargetAddress NextRWDataAddr = ObjAllocs.RemoteRWDataAddr;<br>
> + for (auto &Alloc : ObjAllocs.RWDataAllocs) {<br>
> + NextRWDataAddr =<br>
> + RoundUpToAlignment(NextRWDataAddr, Alloc.getAlign());<br>
> + Dyld.mapSectionAddress(Alloc.getLocalAddress(), NextRWDataAddr);<br>
> + DEBUG(dbgs() << " rw-data: "<br>
> + << static_cast<void *>(Alloc.getLocalAddress())<br>
> + << " -> " << format("0x%016x", NextRWDataAddr)<br>
> + << "\n");<br>
> + Alloc.setRemoteAddress(NextRWDataAddr);<br>
> + NextRWDataAddr += Alloc.getSize();<br>
> + }<br>
> + }<br>
> + Unfinalized.push_back(std::move(ObjAllocs));<br>
> + }<br>
> + Unmapped.clear();<br>
> + }<br>
> +<br>
> + bool finalizeMemory(std::string *ErrMsg = nullptr) override {<br>
> + DEBUG(dbgs() << "Allocator " << Id << " finalizing:\n");<br>
> +<br>
> + for (auto &ObjAllocs : Unfinalized) {<br>
> +<br>
> + for (auto &Alloc : ObjAllocs.CodeAllocs) {<br>
> + DEBUG(dbgs() << " copying code: "<br>
> + << static_cast<void *>(Alloc.getLocalAddress()) << " -> "<br>
> + << format("0x%016x", Alloc.getRemoteAddress()) << " ("<br>
> + << Alloc.getSize() << " bytes)\n");<br>
> + Client.writeMem(Alloc.getRemoteAddress(), Alloc.getLocalAddress(),<br>
> + Alloc.getSize());<br>
> + }<br>
> +<br>
> + if (ObjAllocs.RemoteCodeAddr) {<br>
> + DEBUG(dbgs() << " setting R-X permissions on code block: "<br>
> + << format("0x%016x", ObjAllocs.RemoteCodeAddr) << "\n");<br>
> + Client.setProtections(Id, ObjAllocs.RemoteCodeAddr,<br>
> + sys::Memory::MF_READ | sys::Memory::MF_EXEC);<br>
> + }<br>
> +<br>
> + for (auto &Alloc : ObjAllocs.RODataAllocs) {<br>
> + DEBUG(dbgs() << " copying ro-data: "<br>
> + << static_cast<void *>(Alloc.getLocalAddress()) << " -> "<br>
> + << format("0x%016x", Alloc.getRemoteAddress()) << " ("<br>
> + << Alloc.getSize() << " bytes)\n");<br>
> + Client.writeMem(Alloc.getRemoteAddress(), Alloc.getLocalAddress(),<br>
> + Alloc.getSize());<br>
> + }<br>
> +<br>
> + if (ObjAllocs.RemoteRODataAddr) {<br>
> + DEBUG(dbgs() << " setting R-- permissions on ro-data block: "<br>
> + << format("0x%016x", ObjAllocs.RemoteRODataAddr)<br>
> + << "\n");<br>
> + Client.setProtections(Id, ObjAllocs.RemoteRODataAddr,<br>
> + sys::Memory::MF_READ);<br>
> + }<br>
> +<br>
> + for (auto &Alloc : ObjAllocs.RWDataAllocs) {<br>
> + DEBUG(dbgs() << " copying rw-data: "<br>
> + << static_cast<void *>(Alloc.getLocalAddress()) << " -> "<br>
> + << format("0x%016x", Alloc.getRemoteAddress()) << " ("<br>
> + << Alloc.getSize() << " bytes)\n");<br>
> + Client.writeMem(Alloc.getRemoteAddress(), Alloc.getLocalAddress(),<br>
> + Alloc.getSize());<br>
> + }<br>
> +<br>
> + if (ObjAllocs.RemoteRWDataAddr) {<br>
> + DEBUG(dbgs() << " setting RW- permissions on rw-data block: "<br>
> + << format("0x%016x", ObjAllocs.RemoteRWDataAddr)<br>
> + << "\n");<br>
> + Client.setProtections(Id, ObjAllocs.RemoteRWDataAddr,<br>
> + sys::Memory::MF_READ | sys::Memory::MF_WRITE);<br>
> + }<br>
> + }<br>
> + Unfinalized.clear();<br>
> +<br>
> + return false;<br>
> + }<br>
> +<br>
> + private:<br>
> + class Alloc {<br>
> + public:<br>
> + Alloc(uint64_t Size, unsigned Align)<br>
> + : Size(Size), Align(Align), Contents(new char[Size + Align - 1]),<br>
> + RemoteAddr(0) {}<br>
> +<br>
> + uint64_t getSize() const { return Size; }<br>
> +<br>
> + unsigned getAlign() const { return Align; }<br>
> +<br>
> + char *getLocalAddress() const {<br>
> + uintptr_t LocalAddr = reinterpret_cast<uintptr_t>(Contents.get());<br>
> + LocalAddr = RoundUpToAlignment(LocalAddr, Align);<br>
> + return reinterpret_cast<char *>(LocalAddr);<br>
> + }<br>
> +<br>
> + void setRemoteAddress(TargetAddress RemoteAddr) {<br>
> + this->RemoteAddr = RemoteAddr;<br>
> + }<br>
> +<br>
> + TargetAddress getRemoteAddress() const { return RemoteAddr; }<br>
> +<br>
> + private:<br>
> + uint64_t Size;<br>
> + unsigned Align;<br>
> + std::unique_ptr<char[]> Contents;<br>
> + TargetAddress RemoteAddr;<br>
> + };<br>
> +<br>
> + struct ObjectAllocs {<br>
> + ObjectAllocs()<br>
> + : RemoteCodeAddr(0), RemoteRODataAddr(0), RemoteRWDataAddr(0) {}<br>
> + TargetAddress RemoteCodeAddr;<br>
> + TargetAddress RemoteRODataAddr;<br>
> + TargetAddress RemoteRWDataAddr;<br>
> + std::vector<Alloc> CodeAllocs, RODataAllocs, RWDataAllocs;<br>
> + };<br>
> +<br>
> + OrcRemoteTargetClient &Client;<br>
> + ResourceIdMgr::ResourceId Id;<br>
> + std::vector<ObjectAllocs> Unmapped;<br>
> + std::vector<ObjectAllocs> Unfinalized;<br>
> + };<br>
> +<br>
> + /// Remote indirect stubs manager.<br>
> + class RCIndirectStubsManager : public IndirectStubsManager {<br>
> + public:<br>
> + RCIndirectStubsManager(OrcRemoteTargetClient &Remote,<br>
> + ResourceIdMgr::ResourceId Id)<br>
> + : Remote(Remote), Id(Id) {}<br>
> +<br>
> + ~RCIndirectStubsManager() { Remote.destroyIndirectStubsManager(Id); }<br>
> +<br>
> + std::error_code createStub(StringRef StubName, TargetAddress StubAddr,<br>
> + JITSymbolFlags StubFlags) override {<br>
> + if (auto EC = reserveStubs(1))<br>
> + return EC;<br>
> +<br>
> + return createStubInternal(StubName, StubAddr, StubFlags);<br>
> + }<br>
> +<br>
> + std::error_code createStubs(const StubInitsMap &StubInits) override {<br>
> + if (auto EC = reserveStubs(StubInits.size()))<br>
> + return EC;<br>
> +<br>
> + for (auto &Entry : StubInits)<br>
> + if (auto EC = createStubInternal(Entry.first(), Entry.second.first,<br>
> + Entry.second.second))<br>
> + return EC;<br>
> +<br>
> + return std::error_code();<br>
> + }<br>
> +<br>
> + JITSymbol findStub(StringRef Name, bool ExportedStubsOnly) override {<br>
> + auto I = StubIndexes.find(Name);<br>
> + if (I == StubIndexes.end())<br>
> + return nullptr;<br>
> + auto Key = I->second.first;<br>
> + auto Flags = I->second.second;<br>
> + auto StubSymbol = JITSymbol(getStubAddr(Key), Flags);<br>
> + if (ExportedStubsOnly && !StubSymbol.isExported())<br>
> + return nullptr;<br>
> + return StubSymbol;<br>
> + }<br>
> +<br>
> + JITSymbol findPointer(StringRef Name) override {<br>
> + auto I = StubIndexes.find(Name);<br>
> + if (I == StubIndexes.end())<br>
> + return nullptr;<br>
> + auto Key = I->second.first;<br>
> + auto Flags = I->second.second;<br>
> + return JITSymbol(getPtrAddr(Key), Flags);<br>
> + }<br>
> +<br>
> + std::error_code updatePointer(StringRef Name,<br>
> + TargetAddress NewAddr) override {<br>
> + auto I = StubIndexes.find(Name);<br>
> + assert(I != StubIndexes.end() && "No stub pointer for symbol");<br>
> + auto Key = I->second.first;<br>
> + return Remote.writePointer(getPtrAddr(Key), NewAddr);<br>
> + }<br>
> +<br>
> + private:<br>
> + struct RemoteIndirectStubsInfo {<br>
> + RemoteIndirectStubsInfo(TargetAddress StubBase, TargetAddress PtrBase,<br>
> + unsigned NumStubs)<br>
> + : StubBase(StubBase), PtrBase(PtrBase), NumStubs(NumStubs) {}<br>
> + TargetAddress StubBase;<br>
> + TargetAddress PtrBase;<br>
> + unsigned NumStubs;<br>
> + };<br>
> +<br>
> + OrcRemoteTargetClient &Remote;<br>
> + ResourceIdMgr::ResourceId Id;<br>
> + std::vector<RemoteIndirectStubsInfo> RemoteIndirectStubsInfos;<br>
> + typedef std::pair<uint16_t, uint16_t> StubKey;<br>
> + std::vector<StubKey> FreeStubs;<br>
> + StringMap<std::pair<StubKey, JITSymbolFlags>> StubIndexes;<br>
> +<br>
> + std::error_code reserveStubs(unsigned NumStubs) {<br>
> + if (NumStubs <= FreeStubs.size())<br>
> + return std::error_code();<br>
> +<br>
> + unsigned NewStubsRequired = NumStubs - FreeStubs.size();<br>
> + TargetAddress StubBase;<br>
> + TargetAddress PtrBase;<br>
> + unsigned NumStubsEmitted;<br>
> +<br>
> + Remote.emitIndirectStubs(StubBase, PtrBase, NumStubsEmitted, Id,<br>
> + NewStubsRequired);<br>
> +<br>
> + unsigned NewBlockId = RemoteIndirectStubsInfos.size();<br>
> + RemoteIndirectStubsInfos.push_back(<br>
> + RemoteIndirectStubsInfo(StubBase, PtrBase, NumStubsEmitted));<br>
> +<br>
> + for (unsigned I = 0; I < NumStubsEmitted; ++I)<br>
> + FreeStubs.push_back(std::make_pair(NewBlockId, I));<br>
> +<br>
> + return std::error_code();<br>
> + }<br>
> +<br>
> + std::error_code createStubInternal(StringRef StubName,<br>
> + TargetAddress InitAddr,<br>
> + JITSymbolFlags StubFlags) {<br>
> + auto Key = FreeStubs.back();<br>
> + FreeStubs.pop_back();<br>
> + StubIndexes[StubName] = std::make_pair(Key, StubFlags);<br>
> + return Remote.writePointer(getPtrAddr(Key), InitAddr);<br>
> + }<br>
> +<br>
> + TargetAddress getStubAddr(StubKey K) {<br>
> + assert(RemoteIndirectStubsInfos[K.first].StubBase != 0 &&<br>
> + "Missing stub address");<br>
> + return RemoteIndirectStubsInfos[K.first].StubBase +<br>
> + K.second * Remote.getIndirectStubSize();<br>
> + }<br>
> +<br>
> + TargetAddress getPtrAddr(StubKey K) {<br>
> + assert(RemoteIndirectStubsInfos[K.first].PtrBase != 0 &&<br>
> + "Missing pointer address");<br>
> + return RemoteIndirectStubsInfos[K.first].PtrBase +<br>
> + K.second * Remote.getPointerSize();<br>
> + }<br>
> + };<br>
> +<br>
> + /// Remote compile callback manager.<br>
> + class RCCompileCallbackManager : public JITCompileCallbackManager {<br>
> + public:<br>
> + RCCompileCallbackManager(TargetAddress ErrorHandlerAddress,<br>
> + OrcRemoteTargetClient &Remote)<br>
> + : JITCompileCallbackManager(ErrorHandlerAddress), Remote(Remote) {<br>
> + assert(!Remote.CompileCallback && "Compile callback already set");<br>
> + Remote.CompileCallback = [this](TargetAddress TrampolineAddr) {<br>
> + return executeCompileCallback(TrampolineAddr);<br>
> + };<br>
> + Remote.emitResolverBlock();<br>
> + }<br>
> +<br>
> + private:<br>
> + void grow() {<br>
> + TargetAddress BlockAddr = 0;<br>
> + uint32_t NumTrampolines = 0;<br>
> + auto EC = Remote.emitTrampolineBlock(BlockAddr, NumTrampolines);<br>
> + assert(!EC && "Failed to create trampolines");<br>
> +<br>
> + uint32_t TrampolineSize = Remote.getTrampolineSize();<br>
> + for (unsigned I = 0; I < NumTrampolines; ++I)<br>
> + this->AvailableTrampolines.push_back(BlockAddr + (I * TrampolineSize));<br>
> + }<br>
> +<br>
> + OrcRemoteTargetClient &Remote;<br>
> + };<br>
> +<br>
> + /// Create an OrcRemoteTargetClient.<br>
> + /// Channel is the ChannelT instance to communicate on. It is assumed that<br>
> + /// the channel is ready to be read from and written to.<br>
> + static ErrorOr<OrcRemoteTargetClient> Create(ChannelT &Channel) {<br>
> + std::error_code EC;<br>
> + OrcRemoteTargetClient H(Channel, EC);<br>
> + if (EC)<br>
> + return EC;<br>
> + return H;<br>
> + }<br>
> +<br>
> + /// Call the int(void) function at the given address in the target and return<br>
> + /// its result.<br>
> + std::error_code callIntVoid(int &Result, TargetAddress Addr) {<br>
> + DEBUG(dbgs() << "Calling int(*)(void) " << format("0x%016x", Addr) << "\n");<br>
> +<br>
> + if (auto EC = call<CallIntVoid>(Channel, Addr))<br>
> + return EC;<br>
> +<br>
> + unsigned NextProcId;<br>
> + if (auto EC = listenForCompileRequests(NextProcId))<br>
> + return EC;<br>
> +<br>
> + if (NextProcId != CallIntVoidResponseId)<br>
> + return orcError(OrcErrorCode::UnexpectedRPCCall);<br>
> +<br>
> + return handle<CallIntVoidResponse>(Channel, [&](int R) {<br>
> + Result = R;<br>
> + DEBUG(dbgs() << "Result: " << R << "\n");<br>
> + return std::error_code();<br>
> + });<br>
> + }<br>
> +<br>
> + /// Call the int(int, char*[]) function at the given address in the target and<br>
> + /// return its result.<br>
> + std::error_code callMain(int &Result, TargetAddress Addr,<br>
> + const std::vector<std::string> &Args) {<br>
> + DEBUG(dbgs() << "Calling int(*)(int, char*[]) " << format("0x%016x", Addr)<br>
> + << "\n");<br>
> +<br>
> + if (auto EC = call<CallMain>(Channel, Addr, Args))<br>
> + return EC;<br>
> +<br>
> + unsigned NextProcId;<br>
> + if (auto EC = listenForCompileRequests(NextProcId))<br>
> + return EC;<br>
> +<br>
> + if (NextProcId != CallMainResponseId)<br>
> + return orcError(OrcErrorCode::UnexpectedRPCCall);<br>
> +<br>
> + return handle<CallMainResponse>(Channel, [&](int R) {<br>
> + Result = R;<br>
> + DEBUG(dbgs() << "Result: " << R << "\n");<br>
> + return std::error_code();<br>
> + });<br>
> + }<br>
> +<br>
> + /// Call the void() function at the given address in the target and wait for<br>
> + /// it to finish.<br>
> + std::error_code callVoidVoid(TargetAddress Addr) {<br>
> + DEBUG(dbgs() << "Calling void(*)(void) " << format("0x%016x", Addr)<br>
> + << "\n");<br>
> +<br>
> + if (auto EC = call<CallVoidVoid>(Channel, Addr))<br>
> + return EC;<br>
> +<br>
> + unsigned NextProcId;<br>
> + if (auto EC = listenForCompileRequests(NextProcId))<br>
> + return EC;<br>
> +<br>
> + if (NextProcId != CallVoidVoidResponseId)<br>
> + return orcError(OrcErrorCode::UnexpectedRPCCall);<br>
> +<br>
> + return handle<CallVoidVoidResponse>(Channel, doNothing);<br>
> + }<br>
> +<br>
> + /// Create an RCMemoryManager which will allocate its memory on the remote<br>
> + /// target.<br>
> + std::error_code<br>
> + createRemoteMemoryManager(std::unique_ptr<RCMemoryManager> &MM) {<br>
> + assert(!MM && "MemoryManager should be null before creation.");<br>
> +<br>
> + auto Id = AllocatorIds.getNext();<br>
> + if (auto EC = call<CreateRemoteAllocator>(Channel, Id))<br>
> + return EC;<br>
> + MM = llvm::make_unique<RCMemoryManager>(*this, Id);<br>
> + return std::error_code();<br>
> + }<br>
> +<br>
> + /// Create an RCIndirectStubsManager that will allocate stubs on the remote<br>
> + /// target.<br>
> + std::error_code<br>
> + createIndirectStubsManager(std::unique_ptr<RCIndirectStubsManager> &I) {<br>
> + assert(!I && "Indirect stubs manager should be null before creation.");<br>
> + auto Id = IndirectStubOwnerIds.getNext();<br>
> + if (auto EC = call<CreateIndirectStubsOwner>(Channel, Id))<br>
> + return EC;<br>
> + I = llvm::make_unique<RCIndirectStubsManager>(*this, Id);<br>
> + return std::error_code();<br>
> + }<br>
> +<br>
> + /// Search for symbols in the remote process. Note: This should be used by<br>
> + /// symbol resolvers *after* they've searched the local symbol table in the<br>
> + /// JIT stack.<br>
> + std::error_code getSymbolAddress(TargetAddress &Addr, StringRef Name) {<br>
> + // Check for an 'out-of-band' error, e.g. from an MM destructor.<br>
> + if (ExistingError)<br>
> + return ExistingError;<br>
> +<br>
> + // Request remote symbol address.<br>
> + if (auto EC = call<GetSymbolAddress>(Channel, Name))<br>
> + return EC;<br>
> +<br>
> + return expect<GetSymbolAddressResponse>(Channel, [&](TargetAddress &A) {<br>
> + Addr = A;<br>
> + DEBUG(dbgs() << "Remote address lookup " << Name << " = "<br>
> + << format("0x%016x", Addr) << "\n");<br>
> + return std::error_code();<br>
> + });<br>
> + }<br>
> +<br>
> + /// Get the triple for the remote target.<br>
> + const std::string &getTargetTriple() const { return RemoteTargetTriple; }<br>
> +<br>
> + std::error_code terminateSession() { return call<TerminateSession>(Channel); }<br>
> +<br>
> +private:<br>
> + OrcRemoteTargetClient(ChannelT &Channel, std::error_code &EC)<br>
> + : Channel(Channel), RemotePointerSize(0), RemotePageSize(0),<br>
> + RemoteTrampolineSize(0), RemoteIndirectStubSize(0) {<br>
> + if ((EC = call<GetRemoteInfo>(Channel)))<br>
> + return;<br>
> +<br>
> + EC = expect<GetRemoteInfoResponse>(<br>
> + Channel, readArgs(RemoteTargetTriple, RemotePointerSize, RemotePageSize,<br>
> + RemoteTrampolineSize, RemoteIndirectStubSize));<br>
> + }<br>
> +<br>
> + void destroyRemoteAllocator(ResourceIdMgr::ResourceId Id) {<br>
> + if (auto EC = call<DestroyRemoteAllocator>(Channel, Id)) {<br>
> + // FIXME: This will be triggered by a removeModuleSet call: Propagate<br>
> + // error return up through that.<br>
> + llvm_unreachable("Failed to destroy remote allocator.");<br>
> + AllocatorIds.release(Id);<br>
> + }<br>
> + }<br>
> +<br>
> + std::error_code destroyIndirectStubsManager(ResourceIdMgr::ResourceId Id) {<br>
> + IndirectStubOwnerIds.release(Id);<br>
> + return call<DestroyIndirectStubsOwner>(Channel, Id);<br>
> + }<br>
> +<br>
> + std::error_code emitIndirectStubs(TargetAddress &StubBase,<br>
> + TargetAddress &PtrBase,<br>
> + uint32_t &NumStubsEmitted,<br>
> + ResourceIdMgr::ResourceId Id,<br>
> + uint32_t NumStubsRequired) {<br>
> + if (auto EC = call<EmitIndirectStubs>(Channel, Id, NumStubsRequired))<br>
> + return EC;<br>
> +<br>
> + return expect<EmitIndirectStubsResponse>(<br>
> + Channel, readArgs(StubBase, PtrBase, NumStubsEmitted));<br>
> + }<br>
> +<br>
> + std::error_code emitResolverBlock() {<br>
> + // Check for an 'out-of-band' error, e.g. from an MM destructor.<br>
> + if (ExistingError)<br>
> + return ExistingError;<br>
> +<br>
> + return call<EmitResolverBlock>(Channel);<br>
> + }<br>
> +<br>
> + std::error_code emitTrampolineBlock(TargetAddress &BlockAddr,<br>
> + uint32_t &NumTrampolines) {<br>
> + // Check for an 'out-of-band' error, e.g. from an MM destructor.<br>
> + if (ExistingError)<br>
> + return ExistingError;<br>
> +<br>
> + if (auto EC = call<EmitTrampolineBlock>(Channel))<br>
> + return EC;<br>
> +<br>
> + return expect<EmitTrampolineBlockResponse>(<br>
> + Channel, [&](TargetAddress BAddr, uint32_t NTrampolines) {<br>
> + BlockAddr = BAddr;<br>
> + NumTrampolines = NTrampolines;<br>
> + return std::error_code();<br>
> + });<br>
> + }<br>
> +<br>
> + uint32_t getIndirectStubSize() const { return RemoteIndirectStubSize; }<br>
> + uint32_t getPageSize() const { return RemotePageSize; }<br>
> + uint32_t getPointerSize() const { return RemotePointerSize; }<br>
> +<br>
> + uint32_t getTrampolineSize() const { return RemoteTrampolineSize; }<br>
> +<br>
> + std::error_code listenForCompileRequests(uint32_t &NextId) {<br>
> + // Check for an 'out-of-band' error, e.g. from an MM destructor.<br>
> + if (ExistingError)<br>
> + return ExistingError;<br>
> +<br>
> + if (auto EC = getNextProcId(Channel, NextId))<br>
> + return EC;<br>
> +<br>
> + while (NextId == RequestCompileId) {<br>
> + TargetAddress TrampolineAddr = 0;<br>
> + if (auto EC = handle<RequestCompile>(Channel, readArgs(TrampolineAddr)))<br>
> + return EC;<br>
> +<br>
> + TargetAddress ImplAddr = CompileCallback(TrampolineAddr);<br>
> + if (auto EC = call<RequestCompileResponse>(Channel, ImplAddr))<br>
> + return EC;<br>
> +<br>
> + if (auto EC = getNextProcId(Channel, NextId))<br>
> + return EC;<br>
> + }<br>
> +<br>
> + return std::error_code();<br>
> + }<br>
> +<br>
> + std::error_code readMem(char *Dst, TargetAddress Src, uint64_t Size) {<br>
> + // Check for an 'out-of-band' error, e.g. from an MM destructor.<br>
> + if (ExistingError)<br>
> + return ExistingError;<br>
> +<br>
> + if (auto EC = call<ReadMem>(Channel, Src, Size))<br>
> + return EC;<br>
> +<br>
> + if (auto EC = expect<ReadMemResponse>(<br>
> + Channel, [&]() { return Channel.readBytes(Dst, Size); }))<br>
> + return EC;<br>
> +<br>
> + return std::error_code();<br>
> + }<br>
> +<br>
> + std::error_code reserveMem(TargetAddress &RemoteAddr,<br>
> + ResourceIdMgr::ResourceId Id, uint64_t Size,<br>
> + uint32_t Align) {<br>
> +<br>
> + // Check for an 'out-of-band' error, e.g. from an MM destructor.<br>
> + if (ExistingError)<br>
> + return ExistingError;<br>
> +<br>
> + if (auto EC = call<ReserveMem>(Channel, Id, Size, Align))<br>
> + return EC;<br>
> +<br>
> + if (auto EC = expect<ReserveMemResponse>(Channel, [&](TargetAddress Addr) {<br>
> + RemoteAddr = Addr;<br>
> + return std::error_code();<br>
> + }))<br>
> + return EC;<br>
> +<br>
> + return std::error_code();<br>
> + }<br>
> +<br>
> + std::error_code setProtections(ResourceIdMgr::ResourceId Id,<br>
> + TargetAddress RemoteSegAddr,<br>
> + unsigned ProtFlags) {<br>
> + return call<SetProtections>(Channel, Id, RemoteSegAddr, ProtFlags);<br>
> + }<br>
> +<br>
> + std::error_code writeMem(TargetAddress Addr, const char *Src, uint64_t Size) {<br>
> + // Check for an 'out-of-band' error, e.g. from an MM destructor.<br>
> + if (ExistingError)<br>
> + return ExistingError;<br>
> +<br>
> + // Make the send call.<br>
> + if (auto EC = call<WriteMem>(Channel, Addr, Size))<br>
> + return EC;<br>
> +<br>
> + // Follow this up with the section contents.<br>
> + if (auto EC = Channel.appendBytes(Src, Size))<br>
> + return EC;<br>
> +<br>
> + return Channel.send();<br>
> + }<br>
> +<br>
> + std::error_code writePointer(TargetAddress Addr, TargetAddress PtrVal) {<br>
> + // Check for an 'out-of-band' error, e.g. from an MM destructor.<br>
> + if (ExistingError)<br>
> + return ExistingError;<br>
> +<br>
> + return call<WritePtr>(Channel, Addr, PtrVal);<br>
> + }<br>
> +<br>
> + static std::error_code doNothing() { return std::error_code(); }<br>
> +<br>
> + ChannelT &Channel;<br>
> + std::error_code ExistingError;<br>
> + std::string RemoteTargetTriple;<br>
> + uint32_t RemotePointerSize;<br>
> + uint32_t RemotePageSize;<br>
> + uint32_t RemoteTrampolineSize;<br>
> + uint32_t RemoteIndirectStubSize;<br>
> + ResourceIdMgr AllocatorIds, IndirectStubOwnerIds;<br>
> + std::function<TargetAddress(TargetAddress)> CompileCallback;<br>
> +};<br>
> +<br>
> +} // end namespace remote<br>
> +} // end namespace orc<br>
> +} // end namespace llvm<br>
> +<br>
> +#undef DEBUG_TYPE<br>
> +<br>
> +#endif<br>
><br>
> Added: llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h?rev=257305&view=auto" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h?rev=257305&view=auto</a><br>
> ==============================================================================<br>
> --- llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h (added)<br>
> +++ llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h Sun Jan 10 19:40:11 2016<br>
> @@ -0,0 +1,185 @@<br>
> +//===--- OrcRemoteTargetRPCAPI.h - Orc Remote-target RPC API ----*- C++ -*-===//<br>
> +//<br>
> +// The LLVM Compiler Infrastructure<br>
> +//<br>
> +// This file is distributed under the University of Illinois Open Source<br>
> +// License. See LICENSE.TXT for details.<br>
> +//<br>
> +//===----------------------------------------------------------------------===//<br>
> +//<br>
> +// This file defines the Orc remote-target RPC API. It should not be used<br>
> +// directly, but is used by the RemoteTargetClient and RemoteTargetServer<br>
> +// classes.<br>
> +//<br>
> +//===----------------------------------------------------------------------===//<br>
> +<br>
> +#ifndef LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETRPCAPI_H<br>
> +#define LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETRPCAPI_H<br>
> +<br>
> +#include "JITSymbol.h"<br>
> +#include "RPCChannel.h"<br>
> +#include "RPCUtils.h"<br>
> +<br>
> +namespace llvm {<br>
> +namespace orc {<br>
> +namespace remote {<br>
> +<br>
> +class OrcRemoteTargetRPCAPI : public RPC<RPCChannel> {<br>
> +protected:<br>
> + class ResourceIdMgr {<br>
> + public:<br>
> + typedef uint64_t ResourceId;<br>
> + ResourceIdMgr() : NextId(0) {}<br>
> + ResourceId getNext() {<br>
> + if (!FreeIds.empty()) {<br>
> + ResourceId I = FreeIds.back();<br>
> + FreeIds.pop_back();<br>
> + return I;<br>
> + }<br>
> + return NextId++;<br>
> + }<br>
> + void release(ResourceId I) { FreeIds.push_back(I); }<br>
> +<br>
> + private:<br>
> + ResourceId NextId;<br>
> + std::vector<ResourceId> FreeIds;<br>
> + };<br>
> +<br>
> +public:<br>
> + enum JITProcId : uint32_t {<br>
> + InvalidId = 0,<br>
> + CallIntVoidId,<br>
> + CallIntVoidResponseId,<br>
> + CallMainId,<br>
> + CallMainResponseId,<br>
> + CallVoidVoidId,<br>
> + CallVoidVoidResponseId,<br>
> + CreateRemoteAllocatorId,<br>
> + CreateIndirectStubsOwnerId,<br>
> + DestroyRemoteAllocatorId,<br>
> + DestroyIndirectStubsOwnerId,<br>
> + EmitIndirectStubsId,<br>
> + EmitIndirectStubsResponseId,<br>
> + EmitResolverBlockId,<br>
> + EmitTrampolineBlockId,<br>
> + EmitTrampolineBlockResponseId,<br>
> + GetSymbolAddressId,<br>
> + GetSymbolAddressResponseId,<br>
> + GetRemoteInfoId,<br>
> + GetRemoteInfoResponseId,<br>
> + ReadMemId,<br>
> + ReadMemResponseId,<br>
> + ReserveMemId,<br>
> + ReserveMemResponseId,<br>
> + RequestCompileId,<br>
> + RequestCompileResponseId,<br>
> + SetProtectionsId,<br>
> + TerminateSessionId,<br>
> + WriteMemId,<br>
> + WritePtrId<br>
> + };<br>
> +<br>
> + static const char *getJITProcIdName(JITProcId Id);<br>
> +<br>
> + typedef Procedure<CallIntVoidId, TargetAddress /* FnAddr */> CallIntVoid;<br>
> +<br>
> + typedef Procedure<CallIntVoidResponseId, int /* Result */><br>
> + CallIntVoidResponse;<br>
> +<br>
> + typedef Procedure<CallMainId, TargetAddress /* FnAddr */,<br>
> + std::vector<std::string> /* Args */><br>
> + CallMain;<br>
> +<br>
> + typedef Procedure<CallMainResponseId, int /* Result */> CallMainResponse;<br>
> +<br>
> + typedef Procedure<CallVoidVoidId, TargetAddress /* FnAddr */> CallVoidVoid;<br>
> +<br>
> + typedef Procedure<CallVoidVoidResponseId> CallVoidVoidResponse;<br>
> +<br>
> + typedef Procedure<CreateRemoteAllocatorId,<br>
> + ResourceIdMgr::ResourceId /* Allocator ID */><br>
> + CreateRemoteAllocator;<br>
> +<br>
> + typedef Procedure<CreateIndirectStubsOwnerId,<br>
> + ResourceIdMgr::ResourceId /* StubsOwner ID */><br>
> + CreateIndirectStubsOwner;<br>
> +<br>
> + typedef Procedure<DestroyRemoteAllocatorId,<br>
> + ResourceIdMgr::ResourceId /* Allocator ID */><br>
> + DestroyRemoteAllocator;<br>
> +<br>
> + typedef Procedure<DestroyIndirectStubsOwnerId,<br>
> + ResourceIdMgr::ResourceId /* StubsOwner ID */><br>
> + DestroyIndirectStubsOwner;<br>
> +<br>
> + typedef Procedure<EmitIndirectStubsId,<br>
> + ResourceIdMgr::ResourceId /* StubsOwner ID */,<br>
> + uint32_t /* NumStubsRequired */><br>
> + EmitIndirectStubs;<br>
> +<br>
> + typedef Procedure<<br>
> + EmitIndirectStubsResponseId, TargetAddress /* StubsBaseAddr */,<br>
> + TargetAddress /* PtrsBaseAddr */, uint32_t /* NumStubsEmitted */><br>
> + EmitIndirectStubsResponse;<br>
> +<br>
> + typedef Procedure<EmitResolverBlockId> EmitResolverBlock;<br>
> +<br>
> + typedef Procedure<EmitTrampolineBlockId> EmitTrampolineBlock;<br>
> +<br>
> + typedef Procedure<EmitTrampolineBlockResponseId,<br>
> + TargetAddress /* BlockAddr */,<br>
> + uint32_t /* NumTrampolines */><br>
> + EmitTrampolineBlockResponse;<br>
> +<br>
> + typedef Procedure<GetSymbolAddressId, std::string /*SymbolName*/><br>
> + GetSymbolAddress;<br>
> +<br>
> + typedef Procedure<GetSymbolAddressResponseId, uint64_t /* SymbolAddr */><br>
> + GetSymbolAddressResponse;<br>
> +<br>
> + typedef Procedure<GetRemoteInfoId> GetRemoteInfo;<br>
> +<br>
> + typedef Procedure<GetRemoteInfoResponseId, std::string /* Triple */,<br>
> + uint32_t /* PointerSize */, uint32_t /* PageSize */,<br>
> + uint32_t /* TrampolineSize */,<br>
> + uint32_t /* IndirectStubSize */><br>
> + GetRemoteInfoResponse;<br>
> +<br>
> + typedef Procedure<ReadMemId, TargetAddress /* Src */, uint64_t /* Size */><br>
> + ReadMem;<br>
> +<br>
> + typedef Procedure<ReadMemResponseId> ReadMemResponse;<br>
> +<br>
> + typedef Procedure<ReserveMemId, ResourceIdMgr::ResourceId /* Id */,<br>
> + uint64_t /* Size */, uint32_t /* Align */><br>
> + ReserveMem;<br>
> +<br>
> + typedef Procedure<ReserveMemResponseId, TargetAddress /* Addr */><br>
> + ReserveMemResponse;<br>
> +<br>
> + typedef Procedure<RequestCompileId, TargetAddress /* TrampolineAddr */><br>
> + RequestCompile;<br>
> +<br>
> + typedef Procedure<RequestCompileResponseId, TargetAddress /* ImplAddr */><br>
> + RequestCompileResponse;<br>
> +<br>
> + typedef Procedure<SetProtectionsId, ResourceIdMgr::ResourceId /* Id */,<br>
> + TargetAddress /* Dst */, uint32_t /* ProtFlags */><br>
> + SetProtections;<br>
> +<br>
> + typedef Procedure<TerminateSessionId> TerminateSession;<br>
> +<br>
> + typedef Procedure<WriteMemId, TargetAddress /* Dst */, uint64_t /* Size */<br>
> + /* Data should follow */><br>
> + WriteMem;<br>
> +<br>
> + typedef Procedure<WritePtrId, TargetAddress /* Dst */,<br>
> + TargetAddress /* Val */><br>
> + WritePtr;<br>
> +};<br>
> +<br>
> +} // end namespace remote<br>
> +} // end namespace orc<br>
> +} // end namespace llvm<br>
> +<br>
> +#endif<br>
><br>
> Added: llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h?rev=257305&view=auto" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h?rev=257305&view=auto</a><br>
> ==============================================================================<br>
> --- llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h (added)<br>
> +++ llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h Sun Jan 10 19:40:11 2016<br>
> @@ -0,0 +1,479 @@<br>
> +//===---- OrcRemoteTargetServer.h - Orc Remote-target Server ----*- C++ -*-===//<br>
> +//<br>
> +// The LLVM Compiler Infrastructure<br>
> +//<br>
> +// This file is distributed under the University of Illinois Open Source<br>
> +// License. See LICENSE.TXT for details.<br>
> +//<br>
> +//===----------------------------------------------------------------------===//<br>
> +//<br>
> +// This file defines the OrcRemoteTargetServer class. It can be used to build a<br>
> +// JIT server that can execute code sent from an OrcRemoteTargetClient.<br>
> +//<br>
> +//===----------------------------------------------------------------------===//<br>
> +<br>
> +#ifndef LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETSERVER_H<br>
> +#define LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETSERVER_H<br>
> +<br>
> +#include "OrcRemoteTargetRPCAPI.h"<br>
> +#include "llvm/ExecutionEngine/RTDyldMemoryManager.h"<br>
> +#include "llvm/Support/Debug.h"<br>
> +#include "llvm/Support/Format.h"<br>
> +#include "llvm/Support/Process.h"<br>
> +#include "llvm/Support/raw_ostream.h"<br>
> +#include <map><br>
> +<br>
> +#define DEBUG_TYPE "orc-remote"<br>
> +<br>
> +namespace llvm {<br>
> +namespace orc {<br>
> +namespace remote {<br>
> +<br>
> +template <typename ChannelT, typename TargetT><br>
> +class OrcRemoteTargetServer : public OrcRemoteTargetRPCAPI {<br>
> +public:<br>
> + typedef std::function<TargetAddress(const std::string &Name)><br>
> + SymbolLookupFtor;<br>
> +<br>
> + OrcRemoteTargetServer(ChannelT &Channel, SymbolLookupFtor SymbolLookup)<br>
> + : Channel(Channel), SymbolLookup(std::move(SymbolLookup)) {}<br>
> +<br>
> + std::error_code getNextProcId(JITProcId &Id) {<br>
> + return deserialize(Channel, Id);<br>
> + }<br>
> +<br>
> + std::error_code handleKnownProcedure(JITProcId Id) {<br>
> + DEBUG(dbgs() << "Handling known proc: " << getJITProcIdName(Id) << "\n");<br>
> +<br>
> + switch (Id) {<br>
> + case CallIntVoidId:<br>
> + return handleCallIntVoid();<br>
> + case CallMainId:<br>
> + return handleCallMain();<br>
> + case CallVoidVoidId:<br>
> + return handleCallVoidVoid();<br>
> + case CreateRemoteAllocatorId:<br>
> + return handleCreateRemoteAllocator();<br>
> + case CreateIndirectStubsOwnerId:<br>
> + return handleCreateIndirectStubsOwner();<br>
> + case DestroyRemoteAllocatorId:<br>
> + return handleDestroyRemoteAllocator();<br>
> + case EmitIndirectStubsId:<br>
> + return handleEmitIndirectStubs();<br>
> + case EmitResolverBlockId:<br>
> + return handleEmitResolverBlock();<br>
> + case EmitTrampolineBlockId:<br>
> + return handleEmitTrampolineBlock();<br>
> + case GetSymbolAddressId:<br>
> + return handleGetSymbolAddress();<br>
> + case GetRemoteInfoId:<br>
> + return handleGetRemoteInfo();<br>
> + case ReadMemId:<br>
> + return handleReadMem();<br>
> + case ReserveMemId:<br>
> + return handleReserveMem();<br>
> + case SetProtectionsId:<br>
> + return handleSetProtections();<br>
> + case WriteMemId:<br>
> + return handleWriteMem();<br>
> + case WritePtrId:<br>
> + return handleWritePtr();<br>
> + default:<br>
> + return orcError(OrcErrorCode::UnexpectedRPCCall);<br>
> + }<br>
> +<br>
> + llvm_unreachable("Unhandled JIT RPC procedure Id.");<br>
> + }<br>
> +<br>
> + std::error_code requestCompile(TargetAddress &CompiledFnAddr,<br>
> + TargetAddress TrampolineAddr) {<br>
> + if (auto EC = call<RequestCompile>(Channel, TrampolineAddr))<br>
> + return EC;<br>
> +<br>
> + while (1) {<br>
> + JITProcId Id = InvalidId;<br>
> + if (auto EC = getNextProcId(Id))<br>
> + return EC;<br>
> +<br>
> + switch (Id) {<br>
> + case RequestCompileResponseId:<br>
> + return handle<RequestCompileResponse>(Channel,<br>
> + readArgs(CompiledFnAddr));<br>
> + default:<br>
> + if (auto EC = handleKnownProcedure(Id))<br>
> + return EC;<br>
> + }<br>
> + }<br>
> +<br>
> + llvm_unreachable("Fell through request-compile command loop.");<br>
> + }<br>
> +<br>
> +private:<br>
> + struct Allocator {<br>
> + Allocator() = default;<br>
> + Allocator(Allocator &&) = default;<br>
> + Allocator &operator=(Allocator &&) = default;<br>
> +<br>
> + ~Allocator() {<br>
> + for (auto &Alloc : Allocs)<br>
> + sys::Memory::releaseMappedMemory(Alloc.second);<br>
> + }<br>
> +<br>
> + std::error_code allocate(void *&Addr, size_t Size, uint32_t Align) {<br>
> + std::error_code EC;<br>
> + sys::MemoryBlock MB = sys::Memory::allocateMappedMemory(<br>
> + Size, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);<br>
> + if (EC)<br>
> + return EC;<br>
> +<br>
> + Addr = MB.base();<br>
> + assert(Allocs.find(MB.base()) == Allocs.end() && "Duplicate alloc");<br>
> + Allocs[MB.base()] = std::move(MB);<br>
> + return std::error_code();<br>
> + }<br>
> +<br>
> + std::error_code setProtections(void *block, unsigned Flags) {<br>
> + auto I = Allocs.find(block);<br>
> + if (I == Allocs.end())<br>
> + return orcError(OrcErrorCode::RemoteMProtectAddrUnrecognized);<br>
> + return sys::Memory::protectMappedMemory(I->second, Flags);<br>
> + }<br>
> +<br>
> + private:<br>
> + std::map<void *, sys::MemoryBlock> Allocs;<br>
> + };<br>
> +<br>
> + static std::error_code doNothing() { return std::error_code(); }<br>
> +<br>
> + static TargetAddress reenter(void *JITTargetAddr, void *TrampolineAddr) {<br>
> + TargetAddress CompiledFnAddr = 0;<br>
> +<br>
> + auto T = static_cast<OrcRemoteTargetServer *>(JITTargetAddr);<br>
> + auto EC = T->requestCompile(<br>
> + CompiledFnAddr, static_cast<TargetAddress>(<br>
> + reinterpret_cast<uintptr_t>(TrampolineAddr)));<br>
> + assert(!EC && "Compile request failed");<br>
> + return CompiledFnAddr;<br>
> + }<br>
> +<br>
> + std::error_code handleCallIntVoid() {<br>
> + typedef int (*IntVoidFnTy)();<br>
> +<br>
> + IntVoidFnTy Fn = nullptr;<br>
> + if (auto EC = handle<CallIntVoid>(Channel, [&](TargetAddress Addr) {<br>
> + Fn = reinterpret_cast<IntVoidFnTy>(static_cast<uintptr_t>(Addr));<br>
> + return std::error_code();<br>
> + }))<br>
> + return EC;<br>
> +<br>
> + DEBUG(dbgs() << " Calling " << reinterpret_cast<void *>(Fn) << "\n");<br>
> + int Result = Fn();<br>
> + DEBUG(dbgs() << " Result = " << Result << "\n");<br>
> +<br>
> + return call<CallIntVoidResponse>(Channel, Result);<br>
> + }<br>
> +<br>
> + std::error_code handleCallMain() {<br>
> + typedef int (*MainFnTy)(int, const char *[]);<br>
> +<br>
> + MainFnTy Fn = nullptr;<br>
> + std::vector<std::string> Args;<br>
> + if (auto EC = handle<CallMain>(<br>
> + Channel, [&](TargetAddress Addr, std::vector<std::string> &A) {<br>
> + Fn = reinterpret_cast<MainFnTy>(static_cast<uintptr_t>(Addr));<br>
> + Args = std::move(A);<br>
> + return std::error_code();<br>
> + }))<br>
> + return EC;<br>
> +<br>
> + int ArgC = Args.size() + 1;<br>
> + int Idx = 1;<br>
> + std::unique_ptr<const char *[]> ArgV(new const char *[ArgC + 1]);<br>
> + ArgV[0] = "<jit process>";<br>
> + for (auto &Arg : Args)<br>
> + ArgV[Idx++] = Arg.c_str();<br>
> +<br>
> + DEBUG(dbgs() << " Calling " << reinterpret_cast<void *>(Fn) << "\n");<br>
<br>
</div></div>This is causing a warning:<br>
<br>
/opt/llvm/build-llvm/src/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h:215:5:<br>
warning: ISO C++ forbids casting between pointer-to-function and<br>
pointer-to-object [enabled by default]<br></blockquote><div><br></div><div>I'm not seeing this on a clang self-host. Which compiler is warning about this? (should we enable this warning when building with clang, or disable it when building with whatever is firing it?)<br><br>If it's worth keeping, the easy/reasonable fix is to cast the function pointer to intptr_t first, then to void* to print. (or just to intptr_t then hex format with llvm::format)</div><div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
<span class=""><br>
> + int Result = Fn(ArgC, ArgV.get());<br>
> + DEBUG(dbgs() << " Result = " << Result << "\n");<br>
> +<br>
> + return call<CallMainResponse>(Channel, Result);<br>
> + }<br>
> +<br>
> + std::error_code handleCallVoidVoid() {<br>
> + typedef void (*VoidVoidFnTy)();<br>
> +<br>
> + VoidVoidFnTy Fn = nullptr;<br>
> + if (auto EC = handle<CallIntVoid>(Channel, [&](TargetAddress Addr) {<br>
> + Fn = reinterpret_cast<VoidVoidFnTy>(static_cast<uintptr_t>(Addr));<br>
> + return std::error_code();<br>
> + }))<br>
> + return EC;<br>
> +<br>
> + DEBUG(dbgs() << " Calling " << reinterpret_cast<void *>(Fn) << "\n");<br>
<br>
</span>This is causing the same diagnostic as well.<br>
<br>
I wasn't certain whether you wanted the debugging statements to remain<br>
or not, so I figured I would give you first pass at fixing the issue.<br>
<br>
Thanks!<br>
<br>
~Aaron<br>
<div class="HOEnZb"><div class="h5"><br>
> + Fn();<br>
> + DEBUG(dbgs() << " Complete.\n");<br>
> +<br>
> + return call<CallVoidVoidResponse>(Channel);<br>
> + }<br>
> +<br>
> + std::error_code handleCreateRemoteAllocator() {<br>
> + return handle<CreateRemoteAllocator>(<br>
> + Channel, [&](ResourceIdMgr::ResourceId Id) {<br>
> + auto I = Allocators.find(Id);<br>
> + if (I != Allocators.end())<br>
> + return orcError(OrcErrorCode::RemoteAllocatorIdAlreadyInUse);<br>
> + DEBUG(dbgs() << " Created allocator " << Id << "\n");<br>
> + Allocators[Id] = Allocator();<br>
> + return std::error_code();<br>
> + });<br>
> + }<br>
> +<br>
> + std::error_code handleCreateIndirectStubsOwner() {<br>
> + return handle<CreateIndirectStubsOwner>(<br>
> + Channel, [&](ResourceIdMgr::ResourceId Id) {<br>
> + auto I = IndirectStubsOwners.find(Id);<br>
> + if (I != IndirectStubsOwners.end())<br>
> + return orcError(<br>
> + OrcErrorCode::RemoteIndirectStubsOwnerIdAlreadyInUse);<br>
> + DEBUG(dbgs() << " Create indirect stubs owner " << Id << "\n");<br>
> + IndirectStubsOwners[Id] = ISBlockOwnerList();<br>
> + return std::error_code();<br>
> + });<br>
> + }<br>
> +<br>
> + std::error_code handleDestroyRemoteAllocator() {<br>
> + return handle<DestroyRemoteAllocator>(<br>
> + Channel, [&](ResourceIdMgr::ResourceId Id) {<br>
> + auto I = Allocators.find(Id);<br>
> + if (I == Allocators.end())<br>
> + return orcError(OrcErrorCode::RemoteAllocatorDoesNotExist);<br>
> + Allocators.erase(I);<br>
> + DEBUG(dbgs() << " Destroyed allocator " << Id << "\n");<br>
> + return std::error_code();<br>
> + });<br>
> + }<br>
> +<br>
> + std::error_code handleDestroyIndirectStubsOwner() {<br>
> + return handle<DestroyIndirectStubsOwner>(<br>
> + Channel, [&](ResourceIdMgr::ResourceId Id) {<br>
> + auto I = IndirectStubsOwners.find(Id);<br>
> + if (I == IndirectStubsOwners.end())<br>
> + return orcError(OrcErrorCode::RemoteIndirectStubsOwnerDoesNotExist);<br>
> + IndirectStubsOwners.erase(I);<br>
> + return std::error_code();<br>
> + });<br>
> + }<br>
> +<br>
> + std::error_code handleEmitIndirectStubs() {<br>
> + ResourceIdMgr::ResourceId ISOwnerId = ~0U;<br>
> + uint32_t NumStubsRequired = 0;<br>
> +<br>
> + if (auto EC = handle<EmitIndirectStubs>(<br>
> + Channel, readArgs(ISOwnerId, NumStubsRequired)))<br>
> + return EC;<br>
> +<br>
> + DEBUG(dbgs() << " ISMgr " << ISOwnerId << " request " << NumStubsRequired<br>
> + << " stubs.\n");<br>
> +<br>
> + auto StubOwnerItr = IndirectStubsOwners.find(ISOwnerId);<br>
> + if (StubOwnerItr == IndirectStubsOwners.end())<br>
> + return orcError(OrcErrorCode::RemoteIndirectStubsOwnerDoesNotExist);<br>
> +<br>
> + typename TargetT::IndirectStubsInfo IS;<br>
> + if (auto EC =<br>
> + TargetT::emitIndirectStubsBlock(IS, NumStubsRequired, nullptr))<br>
> + return EC;<br>
> +<br>
> + TargetAddress StubsBase =<br>
> + static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(IS.getStub(0)));<br>
> + TargetAddress PtrsBase =<br>
> + static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(IS.getPtr(0)));<br>
> + uint32_t NumStubsEmitted = IS.getNumStubs();<br>
> +<br>
> + auto &BlockList = StubOwnerItr->second;<br>
> + BlockList.push_back(std::move(IS));<br>
> +<br>
> + return call<EmitIndirectStubsResponse>(Channel, StubsBase, PtrsBase,<br>
> + NumStubsEmitted);<br>
> + }<br>
> +<br>
> + std::error_code handleEmitResolverBlock() {<br>
> + if (auto EC = handle<EmitResolverBlock>(Channel, doNothing))<br>
> + return EC;<br>
> +<br>
> + std::error_code EC;<br>
> + ResolverBlock = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(<br>
> + TargetT::ResolverCodeSize, nullptr,<br>
> + sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));<br>
> + if (EC)<br>
> + return EC;<br>
> +<br>
> + TargetT::writeResolverCode(static_cast<uint8_t *>(ResolverBlock.base()),<br>
> + &reenter, this);<br>
> +<br>
> + return sys::Memory::protectMappedMemory(ResolverBlock.getMemoryBlock(),<br>
> + sys::Memory::MF_READ |<br>
> + sys::Memory::MF_EXEC);<br>
> + }<br>
> +<br>
> + std::error_code handleEmitTrampolineBlock() {<br>
> + if (auto EC = handle<EmitTrampolineBlock>(Channel, doNothing))<br>
> + return EC;<br>
> +<br>
> + std::error_code EC;<br>
> +<br>
> + auto TrampolineBlock =<br>
> + sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(<br>
> + TargetT::PageSize, nullptr,<br>
> + sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));<br>
> + if (EC)<br>
> + return EC;<br>
> +<br>
> + unsigned NumTrampolines =<br>
> + (TargetT::PageSize - TargetT::PointerSize) / TargetT::TrampolineSize;<br>
> +<br>
> + uint8_t *TrampolineMem = static_cast<uint8_t *>(TrampolineBlock.base());<br>
> + TargetT::writeTrampolines(TrampolineMem, ResolverBlock.base(),<br>
> + NumTrampolines);<br>
> +<br>
> + EC = sys::Memory::protectMappedMemory(TrampolineBlock.getMemoryBlock(),<br>
> + sys::Memory::MF_READ |<br>
> + sys::Memory::MF_EXEC);<br>
> +<br>
> + TrampolineBlocks.push_back(std::move(TrampolineBlock));<br>
> +<br>
> + return call<EmitTrampolineBlockResponse>(<br>
> + Channel,<br>
> + static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(TrampolineMem)),<br>
> + NumTrampolines);<br>
> + }<br>
> +<br>
> + std::error_code handleGetSymbolAddress() {<br>
> + std::string SymbolName;<br>
> + if (auto EC = handle<GetSymbolAddress>(Channel, readArgs(SymbolName)))<br>
> + return EC;<br>
> +<br>
> + TargetAddress SymbolAddr = SymbolLookup(SymbolName);<br>
> + DEBUG(dbgs() << " Symbol '" << SymbolName<br>
> + << "' = " << format("0x%016x", SymbolAddr) << "\n");<br>
> + return call<GetSymbolAddressResponse>(Channel, SymbolAddr);<br>
> + }<br>
> +<br>
> + std::error_code handleGetRemoteInfo() {<br>
> + if (auto EC = handle<GetRemoteInfo>(Channel, doNothing))<br>
> + return EC;<br>
> +<br>
> + std::string ProcessTriple = sys::getProcessTriple();<br>
> + uint32_t PointerSize = TargetT::PointerSize;<br>
> + uint32_t PageSize = sys::Process::getPageSize();<br>
> + uint32_t TrampolineSize = TargetT::TrampolineSize;<br>
> + uint32_t IndirectStubSize = TargetT::IndirectStubsInfo::StubSize;<br>
> + DEBUG(dbgs() << " Remote info:\n"<br>
> + << " triple = '" << ProcessTriple << "'\n"<br>
> + << " pointer size = " << PointerSize << "\n"<br>
> + << " page size = " << PageSize << "\n"<br>
> + << " trampoline size = " << TrampolineSize << "\n"<br>
> + << " indirect stub size = " << IndirectStubSize << "\n");<br>
> + return call<GetRemoteInfoResponse>(Channel, ProcessTriple, PointerSize,<br>
> + PageSize, TrampolineSize,<br>
> + IndirectStubSize);<br>
> + }<br>
> +<br>
> + std::error_code handleReadMem() {<br>
> + char *Src = nullptr;<br>
> + uint64_t Size = 0;<br>
> + if (auto EC =<br>
> + handle<ReadMem>(Channel, [&](TargetAddress RSrc, uint64_t RSize) {<br>
> + Src = reinterpret_cast<char *>(static_cast<uintptr_t>(RSrc));<br>
> + Size = RSize;<br>
> + return std::error_code();<br>
> + }))<br>
> + return EC;<br>
> +<br>
> + DEBUG(dbgs() << " Reading " << Size << " bytes from "<br>
> + << static_cast<void *>(Src) << "\n");<br>
> +<br>
> + if (auto EC = call<ReadMemResponse>(Channel))<br>
> + return EC;<br>
> +<br>
> + if (auto EC = Channel.appendBytes(Src, Size))<br>
> + return EC;<br>
> +<br>
> + return Channel.send();<br>
> + }<br>
> +<br>
> + std::error_code handleReserveMem() {<br>
> + void *LocalAllocAddr = nullptr;<br>
> +<br>
> + if (auto EC =<br>
> + handle<ReserveMem>(Channel, [&](ResourceIdMgr::ResourceId Id,<br>
> + uint64_t Size, uint32_t Align) {<br>
> + auto I = Allocators.find(Id);<br>
> + if (I == Allocators.end())<br>
> + return orcError(OrcErrorCode::RemoteAllocatorDoesNotExist);<br>
> + auto &Allocator = I->second;<br>
> + auto EC2 = Allocator.allocate(LocalAllocAddr, Size, Align);<br>
> + DEBUG(dbgs() << " Allocator " << Id << " reserved "<br>
> + << LocalAllocAddr << " (" << Size<br>
> + << " bytes, alignment " << Align << ")\n");<br>
> + return EC2;<br>
> + }))<br>
> + return EC;<br>
> +<br>
> + TargetAddress AllocAddr =<br>
> + static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(LocalAllocAddr));<br>
> +<br>
> + return call<ReserveMemResponse>(Channel, AllocAddr);<br>
> + }<br>
> +<br>
> + std::error_code handleSetProtections() {<br>
> + return handle<ReserveMem>(Channel, [&](ResourceIdMgr::ResourceId Id,<br>
> + TargetAddress Addr, uint32_t Flags) {<br>
> + auto I = Allocators.find(Id);<br>
> + if (I == Allocators.end())<br>
> + return orcError(OrcErrorCode::RemoteAllocatorDoesNotExist);<br>
> + auto &Allocator = I->second;<br>
> + void *LocalAddr = reinterpret_cast<void *>(static_cast<uintptr_t>(Addr));<br>
> + DEBUG(dbgs() << " Allocator " << Id << " set permissions on "<br>
> + << LocalAddr << " to "<br>
> + << (Flags & sys::Memory::MF_READ ? 'R' : '-')<br>
> + << (Flags & sys::Memory::MF_WRITE ? 'W' : '-')<br>
> + << (Flags & sys::Memory::MF_EXEC ? 'X' : '-') << "\n");<br>
> + return Allocator.setProtections(LocalAddr, Flags);<br>
> + });<br>
> + }<br>
> +<br>
> + std::error_code handleWriteMem() {<br>
> + return handle<WriteMem>(Channel, [&](TargetAddress RDst, uint64_t Size) {<br>
> + char *Dst = reinterpret_cast<char *>(static_cast<uintptr_t>(RDst));<br>
> + return Channel.readBytes(Dst, Size);<br>
> + });<br>
> + }<br>
> +<br>
> + std::error_code handleWritePtr() {<br>
> + return handle<WritePtr>(<br>
> + Channel, [&](TargetAddress Addr, TargetAddress PtrVal) {<br>
> + uintptr_t *Ptr =<br>
> + reinterpret_cast<uintptr_t *>(static_cast<uintptr_t>(Addr));<br>
> + *Ptr = static_cast<uintptr_t>(PtrVal);<br>
> + return std::error_code();<br>
> + });<br>
> + }<br>
> +<br>
> + ChannelT &Channel;<br>
> + SymbolLookupFtor SymbolLookup;<br>
> + std::map<ResourceIdMgr::ResourceId, Allocator> Allocators;<br>
> + typedef std::vector<typename TargetT::IndirectStubsInfo> ISBlockOwnerList;<br>
> + std::map<ResourceIdMgr::ResourceId, ISBlockOwnerList> IndirectStubsOwners;<br>
> + sys::OwningMemoryBlock ResolverBlock;<br>
> + std::vector<sys::OwningMemoryBlock> TrampolineBlocks;<br>
> +};<br>
> +<br>
> +} // end namespace remote<br>
> +} // end namespace orc<br>
> +} // end namespace llvm<br>
> +<br>
> +#undef DEBUG_TYPE<br>
> +<br>
> +#endif<br>
><br>
> Added: llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCChannel.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCChannel.h?rev=257305&view=auto" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCChannel.h?rev=257305&view=auto</a><br>
> ==============================================================================<br>
> --- llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCChannel.h (added)<br>
> +++ llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCChannel.h Sun Jan 10 19:40:11 2016<br>
> @@ -0,0 +1,207 @@<br>
> +// -*- c++ -*-<br>
> +<br>
> +#ifndef LLVM_EXECUTIONENGINE_ORC_RPCCHANNEL_H<br>
> +#define LLVM_EXECUTIONENGINE_ORC_RPCCHANNEL_H<br>
> +<br>
> +#include "OrcError.h"<br>
> +#include "llvm/ADT/ArrayRef.h"<br>
> +#include "llvm/Support/Endian.h"<br>
> +<br>
> +#include <system_error><br>
> +#include <unistd.h><br>
> +<br>
> +namespace llvm {<br>
> +namespace orc {<br>
> +namespace remote {<br>
> +<br>
> +/// Interface for byte-streams to be used with RPC.<br>
> +class RPCChannel {<br>
> +public:<br>
> + virtual ~RPCChannel() {}<br>
> +<br>
> + /// Read Size bytes from the stream into *Dst.<br>
> + virtual std::error_code readBytes(char *Dst, unsigned Size) = 0;<br>
> +<br>
> + /// Read size bytes from *Src and append them to the stream.<br>
> + virtual std::error_code appendBytes(const char *Src, unsigned Size) = 0;<br>
> +<br>
> + /// Flush the stream if possible.<br>
> + virtual std::error_code send() = 0;<br>
> +};<br>
> +<br>
> +/// RPC channel that reads from and writes from file descriptors.<br>
> +class FDRPCChannel : public RPCChannel {<br>
> +public:<br>
> + FDRPCChannel(int InFD, int OutFD) : InFD(InFD), OutFD(OutFD) {}<br>
> +<br>
> + std::error_code readBytes(char *Dst, unsigned Size) override {<br>
> + assert(Dst && "Attempt to read into null.");<br>
> + ssize_t ReadResult = ::read(InFD, Dst, Size);<br>
> + if (ReadResult != Size)<br>
> + return std::error_code(errno, std::generic_category());<br>
> + return std::error_code();<br>
> + }<br>
> +<br>
> + std::error_code appendBytes(const char *Src, unsigned Size) override {<br>
> + assert(Src && "Attempt to append from null.");<br>
> + ssize_t WriteResult = ::write(OutFD, Src, Size);<br>
> + if (WriteResult != Size)<br>
> + std::error_code(errno, std::generic_category());<br>
> + return std::error_code();<br>
> + }<br>
> +<br>
> + std::error_code send() override { return std::error_code(); }<br>
> +<br>
> +private:<br>
> + int InFD, OutFD;<br>
> +};<br>
> +<br>
> +/// RPC channel serialization for a variadic list of arguments.<br>
> +template <typename T, typename... Ts><br>
> +std::error_code serialize_seq(RPCChannel &C, const T &Arg, const Ts &... Args) {<br>
> + if (auto EC = serialize(C, Arg))<br>
> + return EC;<br>
> + return serialize_seq(C, Args...);<br>
> +}<br>
> +<br>
> +/// RPC channel serialization for an (empty) variadic list of arguments.<br>
> +inline std::error_code serialize_seq(RPCChannel &C) {<br>
> + return std::error_code();<br>
> +}<br>
> +<br>
> +/// RPC channel deserialization for a variadic list of arguments.<br>
> +template <typename T, typename... Ts><br>
> +std::error_code deserialize_seq(RPCChannel &C, T &Arg, Ts &... Args) {<br>
> + if (auto EC = deserialize(C, Arg))<br>
> + return EC;<br>
> + return deserialize_seq(C, Args...);<br>
> +}<br>
> +<br>
> +/// RPC channel serialization for an (empty) variadic list of arguments.<br>
> +inline std::error_code deserialize_seq(RPCChannel &C) {<br>
> + return std::error_code();<br>
> +}<br>
> +<br>
> +/// RPC channel serialization for integer primitives.<br>
> +template <typename T><br>
> +typename std::enable_if<<br>
> + std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value ||<br>
> + std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value ||<br>
> + std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value ||<br>
> + std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value,<br>
> + std::error_code>::type<br>
> +serialize(RPCChannel &C, T V) {<br>
> + support::endian::byte_swap<T, support::big>(V);<br>
> + return C.appendBytes(reinterpret_cast<const char *>(&V), sizeof(T));<br>
> +}<br>
> +<br>
> +/// RPC channel deserialization for integer primitives.<br>
> +template <typename T><br>
> +typename std::enable_if<<br>
> + std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value ||<br>
> + std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value ||<br>
> + std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value ||<br>
> + std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value,<br>
> + std::error_code>::type<br>
> +deserialize(RPCChannel &C, T &V) {<br>
> + if (auto EC = C.readBytes(reinterpret_cast<char *>(&V), sizeof(T)))<br>
> + return EC;<br>
> + support::endian::byte_swap<T, support::big>(V);<br>
> + return std::error_code();<br>
> +}<br>
> +<br>
> +/// RPC channel serialization for enums.<br>
> +template <typename T><br>
> +typename std::enable_if<std::is_enum<T>::value, std::error_code>::type<br>
> +serialize(RPCChannel &C, T V) {<br>
> + return serialize(C, static_cast<typename std::underlying_type<T>::type>(V));<br>
> +}<br>
> +<br>
> +/// RPC channel deserialization for enums.<br>
> +template <typename T><br>
> +typename std::enable_if<std::is_enum<T>::value, std::error_code>::type<br>
> +deserialize(RPCChannel &C, T &V) {<br>
> + typename std::underlying_type<T>::type Tmp;<br>
> + std::error_code EC = deserialize(C, Tmp);<br>
> + V = static_cast<T>(Tmp);<br>
> + return EC;<br>
> +}<br>
> +<br>
> +/// RPC channel serialization for bools.<br>
> +inline std::error_code serialize(RPCChannel &C, bool V) {<br>
> + uint8_t VN = V ? 1 : 0;<br>
> + return C.appendBytes(reinterpret_cast<const char *>(&VN), 1);<br>
> +}<br>
> +<br>
> +/// RPC channel deserialization for bools.<br>
> +inline std::error_code deserialize(RPCChannel &C, bool &V) {<br>
> + uint8_t VN = 0;<br>
> + if (auto EC = C.readBytes(reinterpret_cast<char *>(&VN), 1))<br>
> + return EC;<br>
> +<br>
> + V = (VN != 0) ? true : false;<br>
> + return std::error_code();<br>
> +}<br>
> +<br>
> +/// RPC channel serialization for StringRefs.<br>
> +/// Note: There is no corresponding deseralization for this, as StringRef<br>
> +/// doesn't own its memory and so can't hold the deserialized data.<br>
> +inline std::error_code serialize(RPCChannel &C, StringRef S) {<br>
> + if (auto EC = serialize(C, static_cast<uint64_t>(S.size())))<br>
> + return EC;<br>
> + return C.appendBytes((const char *)S.bytes_begin(), S.size());<br>
> +}<br>
> +<br>
> +/// RPC channel serialization for std::strings.<br>
> +inline std::error_code serialize(RPCChannel &C, const std::string &S) {<br>
> + return serialize(C, StringRef(S));<br>
> +}<br>
> +<br>
> +/// RPC channel deserialization for std::strings.<br>
> +inline std::error_code deserialize(RPCChannel &C, std::string &S) {<br>
> + uint64_t Count;<br>
> + if (auto EC = deserialize(C, Count))<br>
> + return EC;<br>
> + S.resize(Count);<br>
> + return C.readBytes(&S[0], Count);<br>
> +}<br>
> +<br>
> +/// RPC channel serialization for ArrayRef<T>.<br>
> +template <typename T><br>
> +std::error_code serialize(RPCChannel &C, const ArrayRef<T> &A) {<br>
> + if (auto EC = serialize(C, static_cast<uint64_t>(A.size())))<br>
> + return EC;<br>
> +<br>
> + for (const auto &E : A)<br>
> + if (auto EC = serialize(C, E))<br>
> + return EC;<br>
> +<br>
> + return std::error_code();<br>
> +}<br>
> +<br>
> +/// RPC channel serialization for std::array<T>.<br>
> +template <typename T><br>
> +std::error_code serialize(RPCChannel &C, const std::vector<T> &V) {<br>
> + return serialize(C, ArrayRef<T>(V));<br>
> +}<br>
> +<br>
> +/// RPC channel deserialization for std::array<T>.<br>
> +template <typename T><br>
> +std::error_code deserialize(RPCChannel &C, std::vector<T> &V) {<br>
> + uint64_t Count = 0;<br>
> + if (auto EC = deserialize(C, Count))<br>
> + return EC;<br>
> +<br>
> + V.resize(Count);<br>
> + for (auto &E : V)<br>
> + if (auto EC = deserialize(C, E))<br>
> + return EC;<br>
> +<br>
> + return std::error_code();<br>
> +}<br>
> +<br>
> +} // end namespace remote<br>
> +} // end namespace orc<br>
> +} // end namespace llvm<br>
> +<br>
> +#endif<br>
><br>
> Added: llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h?rev=257305&view=auto" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h?rev=257305&view=auto</a><br>
> ==============================================================================<br>
> --- llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h (added)<br>
> +++ llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h Sun Jan 10 19:40:11 2016<br>
> @@ -0,0 +1,222 @@<br>
> +//===----- RPCUTils.h - Basic tilities for building RPC APIs ----*- C++ -*-===//<br>
> +//<br>
> +// The LLVM Compiler Infrastructure<br>
> +//<br>
> +// This file is distributed under the University of Illinois Open Source<br>
> +// License. See LICENSE.TXT for details.<br>
> +//<br>
> +//===----------------------------------------------------------------------===//<br>
> +//<br>
> +// Basic utilities for building RPC APIs.<br>
> +//<br>
> +//===----------------------------------------------------------------------===//<br>
> +<br>
> +#ifndef LLVM_EXECUTIONENGINE_ORC_RPCUTILS_H<br>
> +#define LLVM_EXECUTIONENGINE_ORC_RPCUTILS_H<br>
> +<br>
> +#include "llvm/ADT/STLExtras.h"<br>
> +<br>
> +namespace llvm {<br>
> +namespace orc {<br>
> +namespace remote {<br>
> +<br>
> +/// Contains primitive utilities for defining, calling and handling calls to<br>
> +/// remote procedures. ChannelT is a bidirectional stream conforming to the<br>
> +/// RPCChannel interface (see RPCChannel.h), and ProcedureIdT is a procedure<br>
> +/// identifier type that must be serializable on ChannelT.<br>
> +///<br>
> +/// These utilities support the construction of very primitive RPC utilities.<br>
> +/// Their intent is to ensure correct serialization and deserialization of<br>
> +/// procedure arguments, and to keep the client and server's view of the API in<br>
> +/// sync.<br>
> +///<br>
> +/// These utilities do not support return values. These can be handled by<br>
> +/// declaring a corresponding '.*Response' procedure and expecting it after a<br>
> +/// call). They also do not support versioning: the client and server *must* be<br>
> +/// compiled with the same procedure definitions.<br>
> +///<br>
> +///<br>
> +///<br>
> +/// Overview (see comments individual types/methods for details):<br>
> +///<br>
> +/// Procedure<Id, Args...> :<br>
> +///<br>
> +/// associates a unique serializable id with an argument list.<br>
> +///<br>
> +///<br>
> +/// call<Proc>(Channel, Args...) :<br>
> +///<br>
> +/// Calls the remote procedure 'Proc' by serializing Proc's id followed by its<br>
> +/// arguments and sending the resulting bytes to 'Channel'.<br>
> +///<br>
> +///<br>
> +/// handle<Proc>(Channel, <functor matching std::error_code(Args...)> :<br>
> +///<br>
> +/// Handles a call to 'Proc' by deserializing its arguments and calling the<br>
> +/// given functor. This assumes that the id for 'Proc' has already been<br>
> +/// deserialized.<br>
> +///<br>
> +/// expect<Proc>(Channel, <functor matching std::error_code(Args...)> :<br>
> +///<br>
> +/// The same as 'handle', except that the procedure id should not have been<br>
> +/// read yet. Expect will deserialize the id and assert that it matches Proc's<br>
> +/// id. If it does not, and unexpected RPC call error is returned.<br>
> +<br>
> +template <typename ChannelT, typename ProcedureIdT = uint32_t> class RPC {<br>
> +public:<br>
> + /// Utility class for defining/referring to RPC procedures.<br>
> + ///<br>
> + /// Typedefs of this utility are used when calling/handling remote procedures.<br>
> + ///<br>
> + /// ProcId should be a unique value of ProcedureIdT (i.e. not used with any<br>
> + /// other Procedure typedef in the RPC API being defined.<br>
> + ///<br>
> + /// the template argument Ts... gives the argument list for the remote<br>
> + /// procedure.<br>
> + ///<br>
> + /// E.g.<br>
> + ///<br>
> + /// typedef Procedure<0, bool> Proc1;<br>
> + /// typedef Procedure<1, std::string, std::vector<int>> Proc2;<br>
> + ///<br>
> + /// if (auto EC = call<Proc1>(Channel, true))<br>
> + /// /* handle EC */;<br>
> + ///<br>
> + /// if (auto EC = expect<Proc2>(Channel,<br>
> + /// [](std::string &S, std::vector<int> &V) {<br>
> + /// // Stuff.<br>
> + /// return std::error_code();<br>
> + /// })<br>
> + /// /* handle EC */;<br>
> + ///<br>
> + template <ProcedureIdT ProcId, typename... Ts> class Procedure {<br>
> + public:<br>
> + static const ProcedureIdT Id = ProcId;<br>
> + };<br>
> +<br>
> +private:<br>
> + template <typename Proc> class CallHelper {};<br>
> +<br>
> + template <ProcedureIdT ProcId, typename... ArgTs><br>
> + class CallHelper<Procedure<ProcId, ArgTs...>> {<br>
> + public:<br>
> + static std::error_code call(ChannelT &C, const ArgTs &... Args) {<br>
> + if (auto EC = serialize(C, ProcId))<br>
> + return EC;<br>
> + // If you see a compile-error on this line you're probably calling a<br>
> + // function with the wrong signature.<br>
> + return serialize_seq(C, Args...);<br>
> + }<br>
> + };<br>
> +<br>
> + template <typename Proc> class HandlerHelper {};<br>
> +<br>
> + template <ProcedureIdT ProcId, typename... ArgTs><br>
> + class HandlerHelper<Procedure<ProcId, ArgTs...>> {<br>
> + public:<br>
> + template <typename HandlerT><br>
> + static std::error_code handle(ChannelT &C, HandlerT Handler) {<br>
> + return readAndHandle(C, Handler, llvm::index_sequence_for<ArgTs...>());<br>
> + }<br>
> +<br>
> + private:<br>
> + template <typename HandlerT, size_t... Is><br>
> + static std::error_code readAndHandle(ChannelT &C, HandlerT Handler,<br>
> + llvm::index_sequence<Is...> _) {<br>
> + std::tuple<ArgTs...> RPCArgs;<br>
> + if (auto EC = deserialize_seq(C, std::get<Is>(RPCArgs)...))<br>
> + return EC;<br>
> + return Handler(std::get<Is>(RPCArgs)...);<br>
> + }<br>
> + };<br>
> +<br>
> + template <typename... ArgTs> class ReadArgs {<br>
> + public:<br>
> + std::error_code operator()() { return std::error_code(); }<br>
> + };<br>
> +<br>
> + template <typename ArgT, typename... ArgTs><br>
> + class ReadArgs<ArgT, ArgTs...> : public ReadArgs<ArgTs...> {<br>
> + public:<br>
> + ReadArgs(ArgT &Arg, ArgTs &... Args)<br>
> + : ReadArgs<ArgTs...>(Args...), Arg(Arg) {}<br>
> +<br>
> + std::error_code operator()(ArgT &ArgVal, ArgTs &... ArgVals) {<br>
> + this->Arg = std::move(ArgVal);<br>
> + return ReadArgs<ArgTs...>::operator()(ArgVals...);<br>
> + }<br>
> +<br>
> + private:<br>
> + ArgT &Arg;<br>
> + };<br>
> +<br>
> +public:<br>
> + /// Serialize Args... to channel C, but do not call C.send().<br>
> + ///<br>
> + /// For buffered channels, this can be used to queue up several calls before<br>
> + /// flushing the channel.<br>
> + template <typename Proc, typename... ArgTs><br>
> + static std::error_code appendCall(ChannelT &C, const ArgTs &... Args) {<br>
> + return CallHelper<Proc>::call(C, Args...);<br>
> + }<br>
> +<br>
> + /// Serialize Args... to channel C and call C.send().<br>
> + template <typename Proc, typename... ArgTs><br>
> + static std::error_code call(ChannelT &C, const ArgTs &... Args) {<br>
> + if (auto EC = appendCall<Proc>(C, Args...))<br>
> + return EC;<br>
> + return C.send();<br>
> + }<br>
> +<br>
> + /// Deserialize and return an enum whose underlying type is ProcedureIdT.<br>
> + static std::error_code getNextProcId(ChannelT &C, ProcedureIdT &Id) {<br>
> + return deserialize(C, Id);<br>
> + }<br>
> +<br>
> + /// Deserialize args for Proc from C and call Handler. The signature of<br>
> + /// handler must conform to 'std::error_code(Args...)' where Args... matches<br>
> + /// the arguments used in the Proc typedef.<br>
> + template <typename Proc, typename HandlerT><br>
> + static std::error_code handle(ChannelT &C, HandlerT Handler) {<br>
> + return HandlerHelper<Proc>::handle(C, Handler);<br>
> + }<br>
> +<br>
> + /// Deserialize a ProcedureIdT from C and verify it matches the id for Proc.<br>
> + /// If the id does match, deserialize the arguments and call the handler<br>
> + /// (similarly to handle).<br>
> + /// If the id does not match, return an unexpect RPC call error and do not<br>
> + /// deserialize any further bytes.<br>
> + template <typename Proc, typename HandlerT><br>
> + static std::error_code expect(ChannelT &C, HandlerT Handler) {<br>
> + ProcedureIdT ProcId;<br>
> + if (auto EC = getNextProcId(C, ProcId))<br>
> + return EC;<br>
> + if (ProcId != Proc::Id)<br>
> + return orcError(OrcErrorCode::UnexpectedRPCCall);<br>
> + return handle<Proc>(C, Handler);<br>
> + }<br>
> +<br>
> + /// Helper for handling setter procedures - this method returns a functor that<br>
> + /// sets the variables referred to by Args... to values deserialized from the<br>
> + /// channel.<br>
> + /// E.g.<br>
> + ///<br>
> + /// typedef Procedure<0, bool, int> Proc1;<br>
> + ///<br>
> + /// ...<br>
> + /// bool B;<br>
> + /// int I;<br>
> + /// if (auto EC = expect<Proc1>(Channel, readArgs(B, I)))<br>
> + /// /* Handle Args */ ;<br>
> + ///<br>
> + template <typename... ArgTs><br>
> + static ReadArgs<ArgTs...> readArgs(ArgTs &... Args) {<br>
> + return ReadArgs<ArgTs...>(Args...);<br>
> + }<br>
> +};<br>
> +<br>
> +} // end namespace remote<br>
> +} // end namespace orc<br>
> +} // end namespace llvm<br>
> +<br>
> +#endif<br>
><br>
> Modified: llvm/trunk/lib/ExecutionEngine/Orc/CMakeLists.txt<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/CMakeLists.txt?rev=257305&r1=257304&r2=257305&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/CMakeLists.txt?rev=257305&r1=257304&r2=257305&view=diff</a><br>
> ==============================================================================<br>
> --- llvm/trunk/lib/ExecutionEngine/Orc/CMakeLists.txt (original)<br>
> +++ llvm/trunk/lib/ExecutionEngine/Orc/CMakeLists.txt Sun Jan 10 19:40:11 2016<br>
> @@ -7,6 +7,7 @@ add_llvm_library(LLVMOrcJIT<br>
> OrcCBindingsStack.cpp<br>
> OrcError.cpp<br>
> OrcMCJITReplacement.cpp<br>
> + OrcRemoteTargetRPCAPI.cpp<br>
><br>
> ADDITIONAL_HEADER_DIRS<br>
> ${LLVM_MAIN_INCLUDE_DIR}/llvm/ExecutionEngine/Orc<br>
><br>
> Added: llvm/trunk/lib/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.cpp?rev=257305&view=auto" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.cpp?rev=257305&view=auto</a><br>
> ==============================================================================<br>
> --- llvm/trunk/lib/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.cpp (added)<br>
> +++ llvm/trunk/lib/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.cpp Sun Jan 10 19:40:11 2016<br>
> @@ -0,0 +1,83 @@<br>
> +//===------- OrcRemoteTargetRPCAPI.cpp - ORC Remote API utilities ---------===//<br>
> +//<br>
> +// The LLVM Compiler Infrastructure<br>
> +//<br>
> +// This file is distributed under the University of Illinois Open Source<br>
> +// License. See LICENSE.TXT for details.<br>
> +//<br>
> +//===----------------------------------------------------------------------===//<br>
> +<br>
> +#include "llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h"<br>
> +<br>
> +namespace llvm {<br>
> +namespace orc {<br>
> +namespace remote {<br>
> +<br>
> +const char *OrcRemoteTargetRPCAPI::getJITProcIdName(JITProcId Id) {<br>
> + switch (Id) {<br>
> + case InvalidId:<br>
> + return "*** Invalid JITProcId ***";<br>
> + case CallIntVoidId:<br>
> + return "CallIntVoid";<br>
> + case CallIntVoidResponseId:<br>
> + return "CallIntVoidResponse";<br>
> + case CallMainId:<br>
> + return "CallMain";<br>
> + case CallMainResponseId:<br>
> + return "CallMainResponse";<br>
> + case CallVoidVoidId:<br>
> + return "CallVoidVoid";<br>
> + case CallVoidVoidResponseId:<br>
> + return "CallVoidVoidResponse";<br>
> + case CreateRemoteAllocatorId:<br>
> + return "CreateRemoteAllocator";<br>
> + case CreateIndirectStubsOwnerId:<br>
> + return "CreateIndirectStubsOwner";<br>
> + case DestroyRemoteAllocatorId:<br>
> + return "DestroyRemoteAllocator";<br>
> + case DestroyIndirectStubsOwnerId:<br>
> + return "DestroyIndirectStubsOwner";<br>
> + case EmitIndirectStubsId:<br>
> + return "EmitIndirectStubs";<br>
> + case EmitIndirectStubsResponseId:<br>
> + return "EmitIndirectStubsResponse";<br>
> + case EmitResolverBlockId:<br>
> + return "EmitResolverBlock";<br>
> + case EmitTrampolineBlockId:<br>
> + return "EmitTrampolineBlock";<br>
> + case EmitTrampolineBlockResponseId:<br>
> + return "EmitTrampolineBlockResponse";<br>
> + case GetSymbolAddressId:<br>
> + return "GetSymbolAddress";<br>
> + case GetSymbolAddressResponseId:<br>
> + return "GetSymbolAddressResponse";<br>
> + case GetRemoteInfoId:<br>
> + return "GetRemoteInfo";<br>
> + case GetRemoteInfoResponseId:<br>
> + return "GetRemoteInfoResponse";<br>
> + case ReadMemId:<br>
> + return "ReadMem";<br>
> + case ReadMemResponseId:<br>
> + return "ReadMemResponse";<br>
> + case ReserveMemId:<br>
> + return "ReserveMem";<br>
> + case ReserveMemResponseId:<br>
> + return "ReserveMemResponse";<br>
> + case RequestCompileId:<br>
> + return "RequestCompile";<br>
> + case RequestCompileResponseId:<br>
> + return "RequestCompileResponse";<br>
> + case SetProtectionsId:<br>
> + return "SetProtections";<br>
> + case TerminateSessionId:<br>
> + return "TerminateSession";<br>
> + case WriteMemId:<br>
> + return "WriteMem";<br>
> + case WritePtrId:<br>
> + return "WritePtr";<br>
> + };<br>
> + return nullptr;<br>
> +}<br>
> +}<br>
> +}<br>
> +}<br>
><br>
> Modified: llvm/trunk/unittests/ExecutionEngine/Orc/CMakeLists.txt<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ExecutionEngine/Orc/CMakeLists.txt?rev=257305&r1=257304&r2=257305&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ExecutionEngine/Orc/CMakeLists.txt?rev=257305&r1=257304&r2=257305&view=diff</a><br>
> ==============================================================================<br>
> --- llvm/trunk/unittests/ExecutionEngine/Orc/CMakeLists.txt (original)<br>
> +++ llvm/trunk/unittests/ExecutionEngine/Orc/CMakeLists.txt Sun Jan 10 19:40:11 2016<br>
> @@ -18,4 +18,5 @@ add_llvm_unittest(OrcJITTests<br>
> ObjectTransformLayerTest.cpp<br>
> OrcCAPITest.cpp<br>
> OrcTestCommon.cpp<br>
> + RPCUtilsTest.cpp<br>
> )<br>
><br>
> Added: llvm/trunk/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp?rev=257305&view=auto" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp?rev=257305&view=auto</a><br>
> ==============================================================================<br>
> --- llvm/trunk/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp (added)<br>
> +++ llvm/trunk/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp Sun Jan 10 19:40:11 2016<br>
> @@ -0,0 +1,147 @@<br>
> +//===----------- RPCUtilsTest.cpp - Unit tests the Orc RPC utils ----------===//<br>
> +//<br>
> +// The LLVM Compiler Infrastructure<br>
> +//<br>
> +// This file is distributed under the University of Illinois Open Source<br>
> +// License. See LICENSE.TXT for details.<br>
> +//<br>
> +//===----------------------------------------------------------------------===//<br>
> +<br>
> +#include "llvm/ExecutionEngine/Orc/RPCChannel.h"<br>
> +#include "llvm/ExecutionEngine/Orc/RPCUtils.h"<br>
> +#include "gtest/gtest.h"<br>
> +<br>
> +#include <queue><br>
> +<br>
> +using namespace llvm;<br>
> +using namespace llvm::orc;<br>
> +using namespace llvm::orc::remote;<br>
> +<br>
> +class QueueChannel : public RPCChannel {<br>
> +public:<br>
> + QueueChannel(std::queue<char> &Queue) : Queue(Queue) {}<br>
> +<br>
> + std::error_code readBytes(char *Dst, unsigned Size) override {<br>
> + while (Size--) {<br>
> + *Dst++ = Queue.front();<br>
> + Queue.pop();<br>
> + }<br>
> + return std::error_code();<br>
> + }<br>
> +<br>
> + std::error_code appendBytes(const char *Src, unsigned Size) override {<br>
> + while (Size--)<br>
> + Queue.push(*Src++);<br>
> + return std::error_code();<br>
> + }<br>
> +<br>
> + std::error_code send() override { return std::error_code(); }<br>
> +<br>
> +private:<br>
> + std::queue<char> &Queue;<br>
> +};<br>
> +<br>
> +class DummyRPC : public testing::Test,<br>
> + public RPC<QueueChannel> {<br>
> +public:<br>
> + typedef Procedure<1, bool> Proc1;<br>
> + typedef Procedure<2, int8_t,<br>
> + uint8_t,<br>
> + int16_t,<br>
> + uint16_t,<br>
> + int32_t,<br>
> + uint32_t,<br>
> + int64_t,<br>
> + uint64_t,<br>
> + bool,<br>
> + std::string,<br>
> + std::vector<int>> AllTheTypes;<br>
> +};<br>
> +<br>
> +<br>
> +TEST_F(DummyRPC, TestBasic) {<br>
> + std::queue<char> Queue;<br>
> + QueueChannel C(Queue);<br>
> +<br>
> + {<br>
> + // Make a call to Proc1.<br>
> + auto EC = call<Proc1>(C, true);<br>
> + EXPECT_FALSE(EC) << "Simple call over queue failed";<br>
> + }<br>
> +<br>
> + {<br>
> + // Expect a call to Proc1.<br>
> + auto EC = expect<Proc1>(C,<br>
> + [&](bool &B) {<br>
> + EXPECT_EQ(B, true)<br>
> + << "Bool serialization broken";<br>
> + return std::error_code();<br>
> + });<br>
> + EXPECT_FALSE(EC) << "Simple expect over queue failed";<br>
> + }<br>
> +}<br>
> +<br>
> +TEST_F(DummyRPC, TestSerialization) {<br>
> + std::queue<char> Queue;<br>
> + QueueChannel C(Queue);<br>
> +<br>
> + {<br>
> + // Make a call to Proc1.<br>
> + std::vector<int> v({42, 7});<br>
> + auto EC = call<AllTheTypes>(C,<br>
> + -101,<br>
> + 250,<br>
> + -10000,<br>
> + 10000,<br>
> + -1000000000,<br>
> + 1000000000,<br>
> + -10000000000,<br>
> + 10000000000,<br>
> + true,<br>
> + "foo",<br>
> + v);<br>
> + EXPECT_FALSE(EC) << "Big (serialization test) call over queue failed";<br>
> + }<br>
> +<br>
> + {<br>
> + // Expect a call to Proc1.<br>
> + auto EC = expect<AllTheTypes>(C,<br>
> + [&](int8_t &s8,<br>
> + uint8_t &u8,<br>
> + int16_t &s16,<br>
> + uint16_t &u16,<br>
> + int32_t &s32,<br>
> + uint32_t &u32,<br>
> + int64_t &s64,<br>
> + uint64_t &u64,<br>
> + bool &b,<br>
> + std::string &s,<br>
> + std::vector<int> &v) {<br>
> +<br>
> + EXPECT_EQ(s8, -101)<br>
> + << "int8_t serialization broken";<br>
> + EXPECT_EQ(u8, 250)<br>
> + << "uint8_t serialization broken";<br>
> + EXPECT_EQ(s16, -10000)<br>
> + << "int16_t serialization broken";<br>
> + EXPECT_EQ(u16, 10000)<br>
> + << "uint16_t serialization broken";<br>
> + EXPECT_EQ(s32, -1000000000)<br>
> + << "int32_t serialization broken";<br>
> + EXPECT_EQ(u32, 1000000000ULL)<br>
> + << "uint32_t serialization broken";<br>
> + EXPECT_EQ(s64, -10000000000)<br>
> + << "int64_t serialization broken";<br>
> + EXPECT_EQ(u64, 10000000000ULL)<br>
> + << "uint64_t serialization broken";<br>
> + EXPECT_EQ(b, true)<br>
> + << "bool serialization broken";<br>
> + EXPECT_EQ(s, "foo")<br>
> + << "std::string serialization broken";<br>
> + EXPECT_EQ(v, std::vector<int>({42, 7}))<br>
> + << "std::vector serialization broken";<br>
> + return std::error_code();<br>
> + });<br>
> + EXPECT_FALSE(EC) << "Big (serialization test) call over queue failed";<br>
> + }<br>
> +}<br>
><br>
><br>
> _______________________________________________<br>
> llvm-commits mailing list<br>
> <a href="mailto:llvm-commits@lists.llvm.org">llvm-commits@lists.llvm.org</a><br>
> <a href="http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits" rel="noreferrer" target="_blank">http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits</a><br>
_______________________________________________<br>
llvm-commits mailing list<br>
<a href="mailto:llvm-commits@lists.llvm.org">llvm-commits@lists.llvm.org</a><br>
<a href="http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits" rel="noreferrer" target="_blank">http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits</a><br>
</div></div></blockquote></div><br></div></div>