From 3869f2a5ab0e4b716553daa1b1170bb5d62fdae0 Mon Sep 17 00:00:00 2001 From: Lang Hames Date: Mon, 25 Apr 2016 21:21:20 +0000 Subject: [PATCH] [ORC] clang-format code that was touched in r267457. NFC. Commit r267457 made a lot of type-substitutions threw off code formatting and alignment. This patch should tidy those changes up. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@267475 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm-c/OrcBindings.h | 16 +- .../llvm/ExecutionEngine/Orc/IndirectionUtils.h | 72 +++---- .../ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h | 73 +++---- include/llvm/ExecutionEngine/Orc/RPCUtils.h | 18 +- lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp | 230 ++++++++++----------- lib/ExecutionEngine/Orc/OrcCBindings.cpp | 11 +- lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp | 45 ++-- lib/ExecutionEngine/Orc/OrcCBindingsStack.h | 112 +++++----- lib/ExecutionEngine/Orc/OrcError.cpp | 4 +- .../Orc/CompileOnDemandLayerTest.cpp | 30 ++- unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp | 113 ++++------ 11 files changed, 322 insertions(+), 402 deletions(-) diff --git a/include/llvm-c/OrcBindings.h b/include/llvm-c/OrcBindings.h index 4a2fa26abd4..de2969ab1c9 100644 --- a/include/llvm-c/OrcBindings.h +++ b/include/llvm-c/OrcBindings.h @@ -32,15 +32,11 @@ extern "C" { typedef struct LLVMOrcOpaqueJITStack *LLVMOrcJITStackRef; typedef uint32_t LLVMOrcModuleHandle; typedef uint64_t LLVMOrcTargetAddress; -typedef uint64_t (*LLVMOrcSymbolResolverFn)(const char *Name, - void *LookupCtx); +typedef uint64_t (*LLVMOrcSymbolResolverFn)(const char *Name, void *LookupCtx); typedef uint64_t (*LLVMOrcLazyCompileCallbackFn)(LLVMOrcJITStackRef JITStack, void *CallbackCtx); -typedef enum { - LLVMOrcErrSuccess = 0, - LLVMOrcErrGeneric -} LLVMOrcErrorCode; +typedef enum { LLVMOrcErrSuccess = 0, LLVMOrcErrGeneric } LLVMOrcErrorCode; /** * Create an ORC JIT stack. @@ -114,10 +110,10 @@ LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack, LLVMModuleRef Mod, /** * Add an object file. */ -LLVMOrcModuleHandle -LLVMOrcAddObjectFile(LLVMOrcJITStackRef JITStack, LLVMObjectFileRef Obj, - LLVMOrcSymbolResolverFn SymbolResolver, - void *SymbolResolverCtx); +LLVMOrcModuleHandle LLVMOrcAddObjectFile(LLVMOrcJITStackRef JITStack, + LLVMObjectFileRef Obj, + LLVMOrcSymbolResolverFn SymbolResolver, + void *SymbolResolverCtx); /** * Remove a module set from the JIT. diff --git a/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h b/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h index 615d6369a64..03306985a3e 100644 --- a/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h +++ b/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h @@ -29,7 +29,6 @@ namespace orc { /// @brief Target-independent base class for compile callback management. class JITCompileCallbackManager { public: - typedef std::function CompileFtor; /// @brief Handle to a newly created compile callback. Can be used to get an @@ -38,12 +37,13 @@ public: class CompileCallbackInfo { public: CompileCallbackInfo(TargetAddress Addr, CompileFtor &Compile) - : Addr(Addr), Compile(Compile) {} + : Addr(Addr), Compile(Compile) {} TargetAddress getAddress() const { return Addr; } void setCompileAction(CompileFtor Compile) { this->Compile = std::move(Compile); } + private: TargetAddress Addr; CompileFtor &Compile; @@ -53,7 +53,7 @@ public: /// @param ErrorHandlerAddress The address of an error handler in the target /// process to be used if a compile callback fails. JITCompileCallbackManager(TargetAddress ErrorHandlerAddress) - : ErrorHandlerAddress(ErrorHandlerAddress) {} + : ErrorHandlerAddress(ErrorHandlerAddress) {} virtual ~JITCompileCallbackManager() {} @@ -69,8 +69,10 @@ public: // Found a callback handler. Yank this trampoline out of the active list and // put it back in the available trampolines list, then try to run the // handler's compile and update actions. - // Moving the trampoline ID back to the available list first means there's at - // least one available trampoline if the compile action triggers a request for + // Moving the trampoline ID back to the available list first means there's + // at + // least one available trampoline if the compile action triggers a request + // for // a new one. auto Compile = std::move(I->second); ActiveTrampolines.erase(I); @@ -116,7 +118,6 @@ protected: std::vector AvailableTrampolines; private: - TargetAddress getAvailableTrampolineAddr() { if (this->AvailableTrampolines.empty()) grow(); @@ -137,20 +138,17 @@ private: template class LocalJITCompileCallbackManager : public JITCompileCallbackManager { public: - /// @brief Construct a InProcessJITCompileCallbackManager. /// @param ErrorHandlerAddress The address of an error handler in the target /// process to be used if a compile callback fails. LocalJITCompileCallbackManager(TargetAddress ErrorHandlerAddress) - : JITCompileCallbackManager(ErrorHandlerAddress) { + : JITCompileCallbackManager(ErrorHandlerAddress) { /// Set up the resolver block. std::error_code EC; - ResolverBlock = - sys::OwningMemoryBlock( - sys::Memory::allocateMappedMemory(TargetT::ResolverCodeSize, nullptr, - sys::Memory::MF_READ | - sys::Memory::MF_WRITE, EC)); + ResolverBlock = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory( + TargetT::ResolverCodeSize, nullptr, + sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC)); assert(!EC && "Failed to allocate resolver block"); TargetT::writeResolverCode(static_cast(ResolverBlock.base()), @@ -163,13 +161,11 @@ public: } private: - static TargetAddress reenter(void *CCMgr, void *TrampolineId) { JITCompileCallbackManager *Mgr = - static_cast(CCMgr); + static_cast(CCMgr); return Mgr->executeCompileCallback( - static_cast( - reinterpret_cast(TrampolineId))); + static_cast(reinterpret_cast(TrampolineId))); } void grow() override { @@ -177,18 +173,16 @@ private: std::error_code EC; auto TrampolineBlock = - sys::OwningMemoryBlock( - sys::Memory::allocateMappedMemory(sys::Process::getPageSize(), nullptr, - sys::Memory::MF_READ | - sys::Memory::MF_WRITE, EC)); + sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory( + sys::Process::getPageSize(), nullptr, + sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC)); assert(!EC && "Failed to allocate trampoline block"); - unsigned NumTrampolines = - (sys::Process::getPageSize() - TargetT::PointerSize) / + (sys::Process::getPageSize() - TargetT::PointerSize) / TargetT::TrampolineSize; - uint8_t *TrampolineMem = static_cast(TrampolineBlock.base()); + uint8_t *TrampolineMem = static_cast(TrampolineBlock.base()); TargetT::writeTrampolines(TrampolineMem, ResolverBlock.base(), NumTrampolines); @@ -212,7 +206,6 @@ private: /// @brief Base class for managing collections of named indirect stubs. class IndirectStubsManager { public: - /// @brief Map type for initializing the manager. See init. typedef StringMap> StubInitsMap; @@ -236,6 +229,7 @@ public: /// @brief Change the value of the implementation pointer for the stub. virtual Error updatePointer(StringRef Name, TargetAddress NewAddr) = 0; + private: virtual void anchor(); }; @@ -245,9 +239,8 @@ private: template class LocalIndirectStubsManager : public IndirectStubsManager { public: - Error createStub(StringRef StubName, TargetAddress StubAddr, - JITSymbolFlags StubFlags) override { + JITSymbolFlags StubFlags) override { if (auto Err = reserveStubs(1)) return Err; @@ -275,7 +268,7 @@ public: void *StubAddr = IndirectStubsInfos[Key.first].getStub(Key.second); assert(StubAddr && "Missing stub address"); auto StubTargetAddr = - static_cast(reinterpret_cast(StubAddr)); + static_cast(reinterpret_cast(StubAddr)); auto StubSymbol = JITSymbol(StubTargetAddr, I->second.second); if (ExportedStubsOnly && !StubSymbol.isExported()) return nullptr; @@ -290,7 +283,7 @@ public: void *PtrAddr = IndirectStubsInfos[Key.first].getPtr(Key.second); assert(PtrAddr && "Missing pointer address"); auto PtrTargetAddr = - static_cast(reinterpret_cast(PtrAddr)); + static_cast(reinterpret_cast(PtrAddr)); return JITSymbol(PtrTargetAddr, I->second.second); } @@ -299,12 +292,11 @@ public: assert(I != StubIndexes.end() && "No stub pointer for symbol"); auto Key = I->second.first; *IndirectStubsInfos[Key.first].getPtr(Key.second) = - reinterpret_cast(static_cast(NewAddr)); + reinterpret_cast(static_cast(NewAddr)); return Error::success(); } private: - Error reserveStubs(unsigned NumStubs) { if (NumStubs <= FreeStubs.size()) return Error::success(); @@ -312,8 +304,8 @@ private: unsigned NewStubsRequired = NumStubs - FreeStubs.size(); unsigned NewBlockId = IndirectStubsInfos.size(); typename TargetT::IndirectStubsInfo ISI; - if (auto Err = TargetT::emitIndirectStubsBlock(ISI, NewStubsRequired, - nullptr)) + if (auto Err = + TargetT::emitIndirectStubsBlock(ISI, NewStubsRequired, nullptr)) return Err; for (unsigned I = 0; I < ISI.getNumStubs(); ++I) FreeStubs.push_back(std::make_pair(NewBlockId, I)); @@ -326,7 +318,7 @@ private: auto Key = FreeStubs.back(); FreeStubs.pop_back(); *IndirectStubsInfos[Key.first].getPtr(Key.second) = - reinterpret_cast(static_cast(InitAddr)); + reinterpret_cast(static_cast(InitAddr)); StubIndexes[StubName] = std::make_pair(Key, StubFlags); } @@ -341,12 +333,12 @@ private: /// /// Usage example: Turn a trampoline address into a function pointer constant /// for use in a stub. -Constant* createIRTypedAddress(FunctionType &FT, TargetAddress Addr); +Constant *createIRTypedAddress(FunctionType &FT, TargetAddress Addr); /// @brief Create a function pointer with the given type, name, and initializer /// in the given Module. -GlobalVariable* createImplPointer(PointerType &PT, Module &M, - const Twine &Name, Constant *Initializer); +GlobalVariable *createImplPointer(PointerType &PT, Module &M, const Twine &Name, + Constant *Initializer); /// @brief Turn a function declaration into a stub function that makes an /// indirect call using the given function pointer. @@ -371,7 +363,7 @@ void makeAllSymbolsExternallyAccessible(Module &M); /// modules with these utilities, all decls should be cloned (and added to a /// single VMap) before any bodies are moved. This will ensure that references /// between functions all refer to the versions in the new module. -Function* cloneFunctionDecl(Module &Dst, const Function &F, +Function *cloneFunctionDecl(Module &Dst, const Function &F, ValueToValueMapTy *VMap = nullptr); /// @brief Move the body of function 'F' to a cloned function declaration in a @@ -387,7 +379,7 @@ void moveFunctionBody(Function &OrigF, ValueToValueMapTy &VMap, Function *NewF = nullptr); /// @brief Clone a global variable declaration into a new module. -GlobalVariable* cloneGlobalVariableDecl(Module &Dst, const GlobalVariable &GV, +GlobalVariable *cloneGlobalVariableDecl(Module &Dst, const GlobalVariable &GV, ValueToValueMapTy *VMap = nullptr); /// @brief Move global variable GV from its parent module to cloned global @@ -404,7 +396,7 @@ void moveGlobalVariableInitializer(GlobalVariable &OrigGV, GlobalVariable *NewGV = nullptr); /// @brief Clone -GlobalAlias* cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA, +GlobalAlias *cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA, ValueToValueMapTy &VMap); } // End namespace orc. diff --git a/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h b/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h index df0b5fe1cf4..74d851522f7 100644 --- a/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h +++ b/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h @@ -28,19 +28,19 @@ class DirectBufferWriter { public: DirectBufferWriter() = default; DirectBufferWriter(const char *Src, TargetAddress Dst, uint64_t Size) - : Src(Src), Dst(Dst), Size(Size) {} + : Src(Src), Dst(Dst), Size(Size) {} const char *getSrc() const { return Src; } TargetAddress getDst() const { return Dst; } uint64_t getSize() const { return Size; } + private: const char *Src; TargetAddress Dst; uint64_t Size; }; -inline Error serialize(RPCChannel &C, - const DirectBufferWriter &DBW) { +inline Error serialize(RPCChannel &C, const DirectBufferWriter &DBW) { if (auto EC = serialize(C, DBW.getDst())) return EC; if (auto EC = serialize(C, DBW.getSize())) @@ -48,15 +48,14 @@ inline Error serialize(RPCChannel &C, return C.appendBytes(DBW.getSrc(), DBW.getSize()); } -inline Error deserialize(RPCChannel &C, - DirectBufferWriter &DBW) { +inline Error deserialize(RPCChannel &C, DirectBufferWriter &DBW) { TargetAddress Dst; if (auto EC = deserialize(C, Dst)) return EC; uint64_t Size; if (auto EC = deserialize(C, Size)) return EC; - char *Addr = reinterpret_cast(static_cast(Dst)); + char *Addr = reinterpret_cast(static_cast(Dst)); DBW = DirectBufferWriter(0, Dst, Size); @@ -65,7 +64,6 @@ inline Error deserialize(RPCChannel &C, class OrcRemoteTargetRPCAPI : public RPC { protected: - class ResourceIdMgr { public: typedef uint64_t ResourceId; @@ -87,16 +85,13 @@ protected: }; public: - // FIXME: Remove constructors once MSVC supports synthesizing move-ops. OrcRemoteTargetRPCAPI() = default; - OrcRemoteTargetRPCAPI(const OrcRemoteTargetRPCAPI&) = delete; - OrcRemoteTargetRPCAPI& operator=(const OrcRemoteTargetRPCAPI&) = delete; + OrcRemoteTargetRPCAPI(const OrcRemoteTargetRPCAPI &) = delete; + OrcRemoteTargetRPCAPI &operator=(const OrcRemoteTargetRPCAPI &) = delete; - OrcRemoteTargetRPCAPI(OrcRemoteTargetRPCAPI&&) {} - OrcRemoteTargetRPCAPI& operator=(OrcRemoteTargetRPCAPI&&) { - return *this; - } + OrcRemoteTargetRPCAPI(OrcRemoteTargetRPCAPI &&) {} + OrcRemoteTargetRPCAPI &operator=(OrcRemoteTargetRPCAPI &&) { return *this; } enum JITFuncId : uint32_t { InvalidId = RPCFunctionIdTraits::InvalidId, @@ -127,80 +122,78 @@ public: typedef Function CallIntVoid; - typedef Function Args)> + typedef Function Args)> CallMain; typedef Function CallVoidVoid; typedef Function + void(ResourceIdMgr::ResourceId AllocatorID)> CreateRemoteAllocator; typedef Function - CreateIndirectStubsOwner; + void(ResourceIdMgr::ResourceId StubOwnerID)> + CreateIndirectStubsOwner; typedef Function + void(TargetAddress Addr, uint32_t Size)> DeregisterEHFrames; typedef Function + void(ResourceIdMgr::ResourceId AllocatorID)> DestroyRemoteAllocator; typedef Function + void(ResourceIdMgr::ResourceId StubsOwnerID)> DestroyIndirectStubsOwner; /// EmitIndirectStubs result is (StubsBase, PtrsBase, NumStubsEmitted). typedef Function( - ResourceIdMgr::ResourceId StubsOwnerID, - uint32_t NumStubsRequired)> + std::tuple( + ResourceIdMgr::ResourceId StubsOwnerID, + uint32_t NumStubsRequired)> EmitIndirectStubs; typedef Function EmitResolverBlock; /// EmitTrampolineBlock result is (BlockAddr, NumTrampolines). - typedef Function()> EmitTrampolineBlock; + typedef Function()> + EmitTrampolineBlock; typedef Function GetSymbolAddress; /// GetRemoteInfo result is (Triple, PointerSize, PageSize, TrampolineSize, /// IndirectStubsSize). - typedef Function()> GetRemoteInfo; + typedef Function()> + GetRemoteInfo; typedef Function(TargetAddress Src, uint64_t Size)> + std::vector(TargetAddress Src, uint64_t Size)> ReadMem; - typedef Function + typedef Function RegisterEHFrames; typedef Function + TargetAddress(ResourceIdMgr::ResourceId AllocID, + uint64_t Size, uint32_t Align)> ReserveMem; typedef Function + TargetAddress(TargetAddress TrampolineAddr)> RequestCompile; typedef Function + void(ResourceIdMgr::ResourceId AllocID, TargetAddress Dst, + uint32_t ProtFlags)> SetProtections; typedef Function TerminateSession; - typedef Function - WriteMem; + typedef Function WriteMem; typedef Function WritePtr; diff --git a/include/llvm/ExecutionEngine/Orc/RPCUtils.h b/include/llvm/ExecutionEngine/Orc/RPCUtils.h index ee5ccf98c04..966a4968434 100644 --- a/include/llvm/ExecutionEngine/Orc/RPCUtils.h +++ b/include/llvm/ExecutionEngine/Orc/RPCUtils.h @@ -327,25 +327,24 @@ template class RPC : public RPCBase { public: - /// RPC default constructor. RPC() = default; /// RPC instances cannot be copied. - RPC(const RPC&) = delete; + RPC(const RPC &) = delete; /// RPC instances cannot be copied. - RPC& operator=(const RPC&) = delete; + RPC &operator=(const RPC &) = delete; /// RPC move constructor. // FIXME: Remove once MSVC can synthesize move ops. RPC(RPC &&Other) - : SequenceNumberMgr(std::move(Other.SequenceNumberMgr)), - OutstandingResults(std::move(Other.OutstandingResults)) {} + : SequenceNumberMgr(std::move(Other.SequenceNumberMgr)), + OutstandingResults(std::move(Other.OutstandingResults)) {} /// RPC move assignment. // FIXME: Remove once MSVC can synthesize move ops. - RPC& operator=(RPC &&Other) { + RPC &operator=(RPC &&Other) { SequenceNumberMgr = std::move(Other.SequenceNumberMgr); OutstandingResults = std::move(Other.OutstandingResults); return *this; @@ -408,7 +407,7 @@ public: createOutstandingResult(std::move(Promise)); if (auto Err = CallHelper::call(C, SeqNo, - Args...)) { + Args...)) { abandonOutstandingResults(); return std::move(Err); } else @@ -435,7 +434,7 @@ public: /// std::future> (or a future for void functions). template Expected> appendCallAsync(ChannelT &C, - const ArgTs &... Args) { + const ArgTs &... Args) { auto ResAndSeqOrErr = appendCallAsyncWithSeq(C, Args...); if (ResAndSeqOrErr) return std::move(ResAndSeqOrErr->first); @@ -445,7 +444,8 @@ public: /// The same as appendCallAsync, except that it calls C.send to flush the /// channel after serializing the call. template - Expected> callAsync(ChannelT &C, const ArgTs &... Args) { + Expected> callAsync(ChannelT &C, + const ArgTs &... Args) { auto ResAndSeqOrErr = callAsyncWithSeq(C, Args...); if (ResAndSeqOrErr) return std::move(ResAndSeqOrErr->first); diff --git a/lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp b/lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp index 4095a3b98ee..b51e3cd002d 100644 --- a/lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp +++ b/lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp @@ -7,8 +7,8 @@ // //===----------------------------------------------------------------------===// -#include "llvm/ADT/Triple.h" #include "llvm/ExecutionEngine/Orc/OrcArchitectureSupport.h" +#include "llvm/ADT/Triple.h" #include "llvm/Support/Process.h" namespace llvm { @@ -18,62 +18,62 @@ void OrcX86_64::writeResolverCode(uint8_t *ResolverMem, JITReentryFn ReentryFn, void *CallbackMgr) { const uint8_t ResolverCode[] = { - // resolver_entry: - 0x55, // 0x00: pushq %rbp - 0x48, 0x89, 0xe5, // 0x01: movq %rsp, %rbp - 0x50, // 0x04: pushq %rax - 0x53, // 0x05: pushq %rbx - 0x51, // 0x06: pushq %rcx - 0x52, // 0x07: pushq %rdx - 0x56, // 0x08: pushq %rsi - 0x57, // 0x09: pushq %rdi - 0x41, 0x50, // 0x0a: pushq %r8 - 0x41, 0x51, // 0x0c: pushq %r9 - 0x41, 0x52, // 0x0e: pushq %r10 - 0x41, 0x53, // 0x10: pushq %r11 - 0x41, 0x54, // 0x12: pushq %r12 - 0x41, 0x55, // 0x14: pushq %r13 - 0x41, 0x56, // 0x16: pushq %r14 - 0x41, 0x57, // 0x18: pushq %r15 - 0x48, 0x81, 0xec, 0x08, 0x02, 0x00, 0x00, // 0x1a: subq 0x208, %rsp - 0x48, 0x0f, 0xae, 0x04, 0x24, // 0x21: fxsave64 (%rsp) - 0x48, 0xbf, // 0x26: movabsq , %rdi - - // 0x28: Callback manager addr. - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - - 0x48, 0x8b, 0x75, 0x08, // 0x30: movq 8(%rbp), %rsi - 0x48, 0x83, 0xee, 0x06, // 0x34: subq $6, %rsi - 0x48, 0xb8, // 0x38: movabsq , %rax - - // 0x3a: JIT re-entry fn addr: - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - - 0xff, 0xd0, // 0x42: callq *%rax - 0x48, 0x89, 0x45, 0x08, // 0x44: movq %rax, 8(%rbp) - 0x48, 0x0f, 0xae, 0x0c, 0x24, // 0x48: fxrstor64 (%rsp) - 0x48, 0x81, 0xc4, 0x08, 0x02, 0x00, 0x00, // 0x4d: addq 0x208, %rsp - 0x41, 0x5f, // 0x54: popq %r15 - 0x41, 0x5e, // 0x56: popq %r14 - 0x41, 0x5d, // 0x58: popq %r13 - 0x41, 0x5c, // 0x5a: popq %r12 - 0x41, 0x5b, // 0x5c: popq %r11 - 0x41, 0x5a, // 0x5e: popq %r10 - 0x41, 0x59, // 0x60: popq %r9 - 0x41, 0x58, // 0x62: popq %r8 - 0x5f, // 0x64: popq %rdi - 0x5e, // 0x65: popq %rsi - 0x5a, // 0x66: popq %rdx - 0x59, // 0x67: popq %rcx - 0x5b, // 0x68: popq %rbx - 0x58, // 0x69: popq %rax - 0x5d, // 0x6a: popq %rbp - 0xc3, // 0x6b: retq + // resolver_entry: + 0x55, // 0x00: pushq %rbp + 0x48, 0x89, 0xe5, // 0x01: movq %rsp, %rbp + 0x50, // 0x04: pushq %rax + 0x53, // 0x05: pushq %rbx + 0x51, // 0x06: pushq %rcx + 0x52, // 0x07: pushq %rdx + 0x56, // 0x08: pushq %rsi + 0x57, // 0x09: pushq %rdi + 0x41, 0x50, // 0x0a: pushq %r8 + 0x41, 0x51, // 0x0c: pushq %r9 + 0x41, 0x52, // 0x0e: pushq %r10 + 0x41, 0x53, // 0x10: pushq %r11 + 0x41, 0x54, // 0x12: pushq %r12 + 0x41, 0x55, // 0x14: pushq %r13 + 0x41, 0x56, // 0x16: pushq %r14 + 0x41, 0x57, // 0x18: pushq %r15 + 0x48, 0x81, 0xec, 0x08, 0x02, 0x00, 0x00, // 0x1a: subq 0x208, %rsp + 0x48, 0x0f, 0xae, 0x04, 0x24, // 0x21: fxsave64 (%rsp) + 0x48, 0xbf, // 0x26: movabsq , %rdi + + // 0x28: Callback manager addr. + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + + 0x48, 0x8b, 0x75, 0x08, // 0x30: movq 8(%rbp), %rsi + 0x48, 0x83, 0xee, 0x06, // 0x34: subq $6, %rsi + 0x48, 0xb8, // 0x38: movabsq , %rax + + // 0x3a: JIT re-entry fn addr: + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + + 0xff, 0xd0, // 0x42: callq *%rax + 0x48, 0x89, 0x45, 0x08, // 0x44: movq %rax, 8(%rbp) + 0x48, 0x0f, 0xae, 0x0c, 0x24, // 0x48: fxrstor64 (%rsp) + 0x48, 0x81, 0xc4, 0x08, 0x02, 0x00, 0x00, // 0x4d: addq 0x208, %rsp + 0x41, 0x5f, // 0x54: popq %r15 + 0x41, 0x5e, // 0x56: popq %r14 + 0x41, 0x5d, // 0x58: popq %r13 + 0x41, 0x5c, // 0x5a: popq %r12 + 0x41, 0x5b, // 0x5c: popq %r11 + 0x41, 0x5a, // 0x5e: popq %r10 + 0x41, 0x59, // 0x60: popq %r9 + 0x41, 0x58, // 0x62: popq %r8 + 0x5f, // 0x64: popq %rdi + 0x5e, // 0x65: popq %rsi + 0x5a, // 0x66: popq %rdx + 0x59, // 0x67: popq %rcx + 0x5b, // 0x68: popq %rbx + 0x58, // 0x69: popq %rax + 0x5d, // 0x6a: popq %rbp + 0xc3, // 0x6b: retq }; const unsigned ReentryFnAddrOffset = 0x3a; const unsigned CallbackMgrAddrOffset = 0x28; - + memcpy(ResolverMem, ResolverCode, sizeof(ResolverCode)); memcpy(ResolverMem + ReentryFnAddrOffset, &ReentryFn, sizeof(ReentryFn)); memcpy(ResolverMem + CallbackMgrAddrOffset, &CallbackMgr, @@ -81,13 +81,13 @@ void OrcX86_64::writeResolverCode(uint8_t *ResolverMem, JITReentryFn ReentryFn, } void OrcX86_64::writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr, - unsigned NumTrampolines) { + unsigned NumTrampolines) { unsigned OffsetToPtr = NumTrampolines * TrampolineSize; - memcpy(TrampolineMem + OffsetToPtr, &ResolverAddr, sizeof(void*)); + memcpy(TrampolineMem + OffsetToPtr, &ResolverAddr, sizeof(void *)); - uint64_t *Trampolines = reinterpret_cast(TrampolineMem); + uint64_t *Trampolines = reinterpret_cast(TrampolineMem); uint64_t CallIndirPCRel = 0xf1c40000000015ff; for (unsigned I = 0; I < NumTrampolines; ++I, OffsetToPtr -= TrampolineSize) @@ -126,36 +126,32 @@ Error OrcX86_64::emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo, // Allocate memory for stubs and pointers in one call. std::error_code EC; - auto StubsMem = - sys::OwningMemoryBlock( - sys::Memory::allocateMappedMemory(2 * NumPages * PageSize, nullptr, - sys::Memory::MF_READ | - sys::Memory::MF_WRITE, - EC)); + auto StubsMem = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory( + 2 * NumPages * PageSize, nullptr, + sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC)); if (EC) return errorCodeToError(EC); // Create separate MemoryBlocks representing the stubs and pointers. sys::MemoryBlock StubsBlock(StubsMem.base(), NumPages * PageSize); - sys::MemoryBlock PtrsBlock(static_cast(StubsMem.base()) + - NumPages * PageSize, + sys::MemoryBlock PtrsBlock(static_cast(StubsMem.base()) + + NumPages * PageSize, NumPages * PageSize); // Populate the stubs page stubs and mark it executable. - uint64_t *Stub = reinterpret_cast(StubsBlock.base()); - uint64_t PtrOffsetField = - static_cast(NumPages * PageSize - 6) << 16; + uint64_t *Stub = reinterpret_cast(StubsBlock.base()); + uint64_t PtrOffsetField = static_cast(NumPages * PageSize - 6) + << 16; for (unsigned I = 0; I < NumStubs; ++I) Stub[I] = 0xF1C40000000025ff | PtrOffsetField; - if (auto EC = sys::Memory::protectMappedMemory(StubsBlock, - sys::Memory::MF_READ | - sys::Memory::MF_EXEC)) + if (auto EC = sys::Memory::protectMappedMemory( + StubsBlock, sys::Memory::MF_READ | sys::Memory::MF_EXEC)) return errorCodeToError(EC); // Initialize all pointers to point at FailureAddress. - void **Ptr = reinterpret_cast(PtrsBlock.base()); + void **Ptr = reinterpret_cast(PtrsBlock.base()); for (unsigned I = 0; I < NumStubs; ++I) Ptr[I] = InitialPtrVal; @@ -168,37 +164,38 @@ void OrcI386::writeResolverCode(uint8_t *ResolverMem, JITReentryFn ReentryFn, void *CallbackMgr) { const uint8_t ResolverCode[] = { - // resolver_entry: - 0x55, // 0x00: pushl %ebp - 0x89, 0xe5, // 0x01: movl %esp, %ebp - 0x54, // 0x03: pushl %esp - 0x83, 0xe4, 0xf0, // 0x04: andl $-0x10, %esp - 0x50, // 0x07: pushl %eax - 0x53, // 0x08: pushl %ebx - 0x51, // 0x09: pushl %ecx - 0x52, // 0x0a: pushl %edx - 0x56, // 0x0b: pushl %esi - 0x57, // 0x0c: pushl %edi - 0x81, 0xec, 0x18, 0x02, 0x00, 0x00, // 0x0d: subl $0x218, %esp - 0x0f, 0xae, 0x44, 0x24, 0x10, // 0x13: fxsave 0x10(%esp) - 0x8b, 0x75, 0x04, // 0x18: movl 0x4(%ebp), %esi - 0x83, 0xee, 0x05, // 0x1b: subl $0x5, %esi - 0x89, 0x74, 0x24, 0x04, // 0x1e: movl %esi, 0x4(%esp) - 0xc7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00, // 0x22: movl , (%esp) - 0xb8, 0x00, 0x00, 0x00, 0x00, // 0x29: movl , %eax - 0xff, 0xd0, // 0x2e: calll *%eax - 0x89, 0x45, 0x04, // 0x30: movl %eax, 0x4(%ebp) - 0x0f, 0xae, 0x4c, 0x24, 0x10, // 0x33: fxrstor 0x10(%esp) - 0x81, 0xc4, 0x18, 0x02, 0x00, 0x00, // 0x38: addl $0x218, %esp - 0x5f, // 0x3e: popl %edi - 0x5e, // 0x3f: popl %esi - 0x5a, // 0x40: popl %edx - 0x59, // 0x41: popl %ecx - 0x5b, // 0x42: popl %ebx - 0x58, // 0x43: popl %eax - 0x8b, 0x65, 0xfc, // 0x44: movl -0x4(%ebp), %esp - 0x5d, // 0x48: popl %ebp - 0xc3 // 0x49: retl + // resolver_entry: + 0x55, // 0x00: pushl %ebp + 0x89, 0xe5, // 0x01: movl %esp, %ebp + 0x54, // 0x03: pushl %esp + 0x83, 0xe4, 0xf0, // 0x04: andl $-0x10, %esp + 0x50, // 0x07: pushl %eax + 0x53, // 0x08: pushl %ebx + 0x51, // 0x09: pushl %ecx + 0x52, // 0x0a: pushl %edx + 0x56, // 0x0b: pushl %esi + 0x57, // 0x0c: pushl %edi + 0x81, 0xec, 0x18, 0x02, 0x00, 0x00, // 0x0d: subl $0x218, %esp + 0x0f, 0xae, 0x44, 0x24, 0x10, // 0x13: fxsave 0x10(%esp) + 0x8b, 0x75, 0x04, // 0x18: movl 0x4(%ebp), %esi + 0x83, 0xee, 0x05, // 0x1b: subl $0x5, %esi + 0x89, 0x74, 0x24, 0x04, // 0x1e: movl %esi, 0x4(%esp) + 0xc7, 0x04, 0x24, 0x00, 0x00, 0x00, + 0x00, // 0x22: movl , (%esp) + 0xb8, 0x00, 0x00, 0x00, 0x00, // 0x29: movl , %eax + 0xff, 0xd0, // 0x2e: calll *%eax + 0x89, 0x45, 0x04, // 0x30: movl %eax, 0x4(%ebp) + 0x0f, 0xae, 0x4c, 0x24, 0x10, // 0x33: fxrstor 0x10(%esp) + 0x81, 0xc4, 0x18, 0x02, 0x00, 0x00, // 0x38: addl $0x218, %esp + 0x5f, // 0x3e: popl %edi + 0x5e, // 0x3f: popl %esi + 0x5a, // 0x40: popl %edx + 0x59, // 0x41: popl %ecx + 0x5b, // 0x42: popl %ebx + 0x58, // 0x43: popl %eax + 0x8b, 0x65, 0xfc, // 0x44: movl -0x4(%ebp), %esp + 0x5d, // 0x48: popl %ebp + 0xc3 // 0x49: retl }; const unsigned ReentryFnAddrOffset = 0x2a; @@ -216,16 +213,15 @@ void OrcI386::writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr, uint64_t CallRelImm = 0xF1C4C400000000e8; uint64_t Resolver = reinterpret_cast(ResolverAddr); uint64_t ResolverRel = - Resolver - reinterpret_cast(TrampolineMem) - 5; + Resolver - reinterpret_cast(TrampolineMem) - 5; - uint64_t *Trampolines = reinterpret_cast(TrampolineMem); + uint64_t *Trampolines = reinterpret_cast(TrampolineMem); for (unsigned I = 0; I < NumTrampolines; ++I, ResolverRel -= TrampolineSize) Trampolines[I] = CallRelImm | (ResolverRel << 8); } Error OrcI386::emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo, - unsigned MinStubs, - void *InitialPtrVal) { + unsigned MinStubs, void *InitialPtrVal) { // Stub format is: // // .section __orc_stubs @@ -255,35 +251,31 @@ Error OrcI386::emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo, // Allocate memory for stubs and pointers in one call. std::error_code EC; - auto StubsMem = - sys::OwningMemoryBlock( - sys::Memory::allocateMappedMemory(2 * NumPages * PageSize, nullptr, - sys::Memory::MF_READ | - sys::Memory::MF_WRITE, - EC)); + auto StubsMem = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory( + 2 * NumPages * PageSize, nullptr, + sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC)); if (EC) return errorCodeToError(EC); // Create separate MemoryBlocks representing the stubs and pointers. sys::MemoryBlock StubsBlock(StubsMem.base(), NumPages * PageSize); - sys::MemoryBlock PtrsBlock(static_cast(StubsMem.base()) + - NumPages * PageSize, + sys::MemoryBlock PtrsBlock(static_cast(StubsMem.base()) + + NumPages * PageSize, NumPages * PageSize); // Populate the stubs page stubs and mark it executable. - uint64_t *Stub = reinterpret_cast(StubsBlock.base()); + uint64_t *Stub = reinterpret_cast(StubsBlock.base()); uint64_t PtrAddr = reinterpret_cast(PtrsBlock.base()); for (unsigned I = 0; I < NumStubs; ++I, PtrAddr += 4) Stub[I] = 0xF1C40000000025ff | (PtrAddr << 16); - if (auto EC = sys::Memory::protectMappedMemory(StubsBlock, - sys::Memory::MF_READ | - sys::Memory::MF_EXEC)) + if (auto EC = sys::Memory::protectMappedMemory( + StubsBlock, sys::Memory::MF_READ | sys::Memory::MF_EXEC)) return errorCodeToError(EC); // Initialize all pointers to point at FailureAddress. - void **Ptr = reinterpret_cast(PtrsBlock.base()); + void **Ptr = reinterpret_cast(PtrsBlock.base()); for (unsigned I = 0; I < NumStubs; ++I) Ptr[I] = InitialPtrVal; diff --git a/lib/ExecutionEngine/Orc/OrcCBindings.cpp b/lib/ExecutionEngine/Orc/OrcCBindings.cpp index 565a9d03ec9..4153f7f0cc9 100644 --- a/lib/ExecutionEngine/Orc/OrcCBindings.cpp +++ b/lib/ExecutionEngine/Orc/OrcCBindings.cpp @@ -19,11 +19,10 @@ LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM) { auto CompileCallbackMgr = OrcCBindingsStack::createCompileCallbackMgr(T); auto IndirectStubsMgrBuilder = - OrcCBindingsStack::createIndirectStubsMgrBuilder(T); + OrcCBindingsStack::createIndirectStubsMgrBuilder(T); - OrcCBindingsStack *JITStack = - new OrcCBindingsStack(*TM2, std::move(CompileCallbackMgr), - IndirectStubsMgrBuilder); + OrcCBindingsStack *JITStack = new OrcCBindingsStack( + *TM2, std::move(CompileCallbackMgr), IndirectStubsMgrBuilder); return wrap(JITStack); } @@ -41,9 +40,7 @@ void LLVMOrcGetMangledSymbol(LLVMOrcJITStackRef JITStack, char **MangledName, strcpy(*MangledName, Mangled.c_str()); } -void LLVMOrcDisposeMangledSymbol(char *MangledName) { - delete[] MangledName; -} +void LLVMOrcDisposeMangledSymbol(char *MangledName) { delete[] MangledName; } LLVMOrcTargetAddress LLVMOrcCreateLazyCompileCallback(LLVMOrcJITStackRef JITStack, diff --git a/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp b/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp index 412e605fc0b..10f6692e9ff 100644 --- a/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp +++ b/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp @@ -20,35 +20,36 @@ using namespace llvm; std::unique_ptr OrcCBindingsStack::createCompileCallbackMgr(Triple T) { switch (T.getArch()) { - default: return nullptr; + default: + return nullptr; - case Triple::x86: { - typedef orc::LocalJITCompileCallbackManager CCMgrT; - return llvm::make_unique(0); - }; + case Triple::x86: { + typedef orc::LocalJITCompileCallbackManager CCMgrT; + return llvm::make_unique(0); + }; - case Triple::x86_64: { - typedef orc::LocalJITCompileCallbackManager CCMgrT; - return llvm::make_unique(0); - } + case Triple::x86_64: { + typedef orc::LocalJITCompileCallbackManager CCMgrT; + return llvm::make_unique(0); + } } } OrcCBindingsStack::IndirectStubsManagerBuilder OrcCBindingsStack::createIndirectStubsMgrBuilder(Triple T) { switch (T.getArch()) { - default: return nullptr; - - case Triple::x86: - return [](){ - return llvm::make_unique< - orc::LocalIndirectStubsManager>(); - }; - - case Triple::x86_64: - return [](){ - return llvm::make_unique< - orc::LocalIndirectStubsManager>(); - }; + default: + return nullptr; + + case Triple::x86: + return []() { + return llvm::make_unique>(); + }; + + case Triple::x86_64: + return []() { + return llvm::make_unique< + orc::LocalIndirectStubsManager>(); + }; } } diff --git a/lib/ExecutionEngine/Orc/OrcCBindingsStack.h b/lib/ExecutionEngine/Orc/OrcCBindingsStack.h index 6b84c7b523f..508ce62c88d 100644 --- a/lib/ExecutionEngine/Orc/OrcCBindingsStack.h +++ b/lib/ExecutionEngine/Orc/OrcCBindingsStack.h @@ -10,6 +10,7 @@ #ifndef LLVM_LIB_EXECUTIONENGINE_ORC_ORCCBINDINGSSTACK_H #define LLVM_LIB_EXECUTIONENGINE_ORC_ORCCBINDINGSSTACK_H +#include "llvm-c/OrcBindings.h" #include "llvm/ADT/Triple.h" #include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h" #include "llvm/ExecutionEngine/Orc/CompileUtils.h" @@ -18,7 +19,6 @@ #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h" #include "llvm/IR/LLVMContext.h" #include "llvm/Support/Error.h" -#include "llvm-c/OrcBindings.h" namespace llvm { @@ -29,19 +29,18 @@ DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef) class OrcCBindingsStack { public: - typedef orc::JITCompileCallbackManager CompileCallbackMgr; typedef orc::ObjectLinkingLayer<> ObjLayerT; typedef orc::IRCompileLayer CompileLayerT; - typedef orc::CompileOnDemandLayer CODLayerT; + typedef orc::CompileOnDemandLayer + CODLayerT; typedef std::function()> - CallbackManagerBuilder; + CallbackManagerBuilder; typedef CODLayerT::IndirectStubsManagerBuilderT IndirectStubsManagerBuilder; private: - class GenericHandle { public: virtual ~GenericHandle() {} @@ -50,20 +49,17 @@ private: virtual void removeModule() = 0; }; - template - class GenericHandleImpl : public GenericHandle { + template class GenericHandleImpl : public GenericHandle { public: GenericHandleImpl(LayerT &Layer, typename LayerT::ModuleSetHandleT Handle) - : Layer(Layer), Handle(std::move(Handle)) {} + : Layer(Layer), Handle(std::move(Handle)) {} orc::JITSymbol findSymbolIn(const std::string &Name, bool ExportedSymbolsOnly) override { return Layer.findSymbolIn(Handle, Name, ExportedSymbolsOnly); } - void removeModule() override { - return Layer.removeModuleSet(Handle); - } + void removeModule() override { return Layer.removeModuleSet(Handle); } private: LayerT &Layer; @@ -78,7 +74,6 @@ private: } public: - // We need a 'ModuleSetHandleT' to conform to the layer concept. typedef unsigned ModuleSetHandleT; @@ -125,22 +120,20 @@ public: createLazyCompileCallback(LLVMOrcLazyCompileCallbackFn Callback, void *CallbackCtx) { auto CCInfo = CCMgr->getCompileCallback(); - CCInfo.setCompileAction( - [=]() -> orc::TargetAddress { - return Callback(wrap(this), CallbackCtx); - }); + CCInfo.setCompileAction([=]() -> orc::TargetAddress { + return Callback(wrap(this), CallbackCtx); + }); return CCInfo.getAddress(); } - LLVMOrcErrorCode - createIndirectStub(StringRef StubName, orc::TargetAddress Addr) { + LLVMOrcErrorCode createIndirectStub(StringRef StubName, + orc::TargetAddress Addr) { return mapError( - IndirectStubsMgr->createStub(StubName, Addr, - JITSymbolFlags::Exported)); + IndirectStubsMgr->createStub(StubName, Addr, JITSymbolFlags::Exported)); } - LLVMOrcErrorCode - setIndirectStubPointer(StringRef Name, orc::TargetAddress Addr) { + LLVMOrcErrorCode setIndirectStubPointer(StringRef Name, + orc::TargetAddress Addr) { return mapError(IndirectStubsMgr->updatePointer(Name, Addr)); } @@ -148,36 +141,33 @@ public: createResolver(LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx) { auto Resolver = orc::createLambdaResolver( - [this, ExternalResolver, ExternalResolverCtx](const std::string &Name) { - // Search order: - // 1. JIT'd symbols. - // 2. Runtime overrides. - // 3. External resolver (if present). - - if (auto Sym = CODLayer.findSymbol(Name, true)) - return RuntimeDyld::SymbolInfo(Sym.getAddress(), - Sym.getFlags()); - if (auto Sym = CXXRuntimeOverrides.searchOverrides(Name)) - return Sym; - - if (ExternalResolver) - return RuntimeDyld::SymbolInfo(ExternalResolver(Name.c_str(), - ExternalResolverCtx), - llvm::JITSymbolFlags::Exported); - - return RuntimeDyld::SymbolInfo(nullptr); - }, - [](const std::string &Name) { - return RuntimeDyld::SymbolInfo(nullptr); - } - ); + [this, ExternalResolver, ExternalResolverCtx](const std::string &Name) { + // Search order: + // 1. JIT'd symbols. + // 2. Runtime overrides. + // 3. External resolver (if present). + + if (auto Sym = CODLayer.findSymbol(Name, true)) + return RuntimeDyld::SymbolInfo(Sym.getAddress(), Sym.getFlags()); + if (auto Sym = CXXRuntimeOverrides.searchOverrides(Name)) + return Sym; + + if (ExternalResolver) + return RuntimeDyld::SymbolInfo( + ExternalResolver(Name.c_str(), ExternalResolverCtx), + llvm::JITSymbolFlags::Exported); + + return RuntimeDyld::SymbolInfo(nullptr); + }, + [](const std::string &Name) { + return RuntimeDyld::SymbolInfo(nullptr); + }); return std::shared_ptr(std::move(Resolver)); } template - ModuleHandleT addIRModule(LayerT &Layer, - Module *M, + ModuleHandleT addIRModule(LayerT &Layer, Module *M, std::unique_ptr MemMgr, LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx) { @@ -198,7 +188,7 @@ public: auto Resolver = createResolver(ExternalResolver, ExternalResolverCtx); // Add the module to the JIT. - std::vector S; + std::vector S; S.push_back(std::move(M)); auto LH = Layer.addModuleSet(std::move(S), std::move(MemMgr), @@ -215,7 +205,7 @@ public: return H; } - ModuleHandleT addIRModuleEager(Module* M, + ModuleHandleT addIRModuleEager(Module *M, LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx) { return addIRModule(CompileLayer, std::move(M), @@ -223,11 +213,11 @@ public: std::move(ExternalResolver), ExternalResolverCtx); } - ModuleHandleT addIRModuleLazy(Module* M, + ModuleHandleT addIRModuleLazy(Module *M, LLVMOrcSymbolResolverFn ExternalResolver, void *ExternalResolverCtx) { return addIRModule(CODLayer, std::move(M), - llvm::make_unique(), + llvm::make_unique(), std::move(ExternalResolver), ExternalResolverCtx); } @@ -248,12 +238,9 @@ public: return GenericHandles[H]->findSymbolIn(Name, ExportedSymbolsOnly); } - const std::string& getErrorMessage() const { - return ErrMsg; - } + const std::string &getErrorMessage() const { return ErrMsg; } private: - template unsigned createHandle(LayerT &Layer, typename LayerT::ModuleSetHandleT Handle) { @@ -272,14 +259,13 @@ private: LLVMOrcErrorCode mapError(Error Err) { LLVMOrcErrorCode Result = LLVMOrcErrSuccess; - handleAllErrors(std::move(Err), - [&](ErrorInfoBase &EIB) { - // Handler of last resort. - Result = LLVMOrcErrGeneric; - ErrMsg = ""; - raw_string_ostream ErrStream(ErrMsg); - EIB.log(ErrStream); - }); + handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) { + // Handler of last resort. + Result = LLVMOrcErrGeneric; + ErrMsg = ""; + raw_string_ostream ErrStream(ErrMsg); + EIB.log(ErrStream); + }); return Result; } diff --git a/lib/ExecutionEngine/Orc/OrcError.cpp b/lib/ExecutionEngine/Orc/OrcError.cpp index 37b49903ba7..58889cc7bc1 100644 --- a/lib/ExecutionEngine/Orc/OrcError.cpp +++ b/lib/ExecutionEngine/Orc/OrcError.cpp @@ -53,8 +53,8 @@ namespace orc { Error orcError(OrcErrorCode ErrCode) { typedef std::underlying_type::type UT; - return errorCodeToError(std::error_code(static_cast(ErrCode), - *OrcErrCat)); + return errorCodeToError( + std::error_code(static_cast(ErrCode), *OrcErrCat)); } } } diff --git a/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp b/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp index fedf163e4fb..8140a1ff249 100644 --- a/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp +++ b/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp @@ -18,7 +18,8 @@ namespace { class DummyCallbackManager : public orc::JITCompileCallbackManager { public: - DummyCallbackManager() : JITCompileCallbackManager(0) { } + DummyCallbackManager() : JITCompileCallbackManager(0) {} + public: void grow() override { llvm_unreachable("not implemented"); } }; @@ -26,7 +27,7 @@ public: class DummyStubsManager : public orc::IndirectStubsManager { public: Error createStub(StringRef StubName, TargetAddress InitAddr, - JITSymbolFlags Flags) override { + JITSymbolFlags Flags) override { llvm_unreachable("Not implemented"); } @@ -42,22 +43,20 @@ public: llvm_unreachable("Not implemented"); } - Error updatePointer(StringRef Name, - TargetAddress NewAddr) override { + Error updatePointer(StringRef Name, TargetAddress NewAddr) override { llvm_unreachable("Not implemented"); } }; TEST(CompileOnDemandLayerTest, FindSymbol) { - auto MockBaseLayer = - createMockBaseLayer(DoNothingAndReturn(0), - DoNothingAndReturn(), - [](const std::string &Name, bool) { - if (Name == "foo") - return JITSymbol(1, JITSymbolFlags::Exported); - return JITSymbol(nullptr); - }, - DoNothingAndReturn(nullptr)); + auto MockBaseLayer = createMockBaseLayer( + DoNothingAndReturn(0), DoNothingAndReturn(), + [](const std::string &Name, bool) { + if (Name == "foo") + return JITSymbol(1, JITSymbolFlags::Exported); + return JITSymbol(nullptr); + }, + DoNothingAndReturn(nullptr)); typedef decltype(MockBaseLayer) MockBaseLayerT; DummyCallbackManager CallbackMgr; @@ -68,8 +67,7 @@ TEST(CompileOnDemandLayerTest, FindSymbol) { auto Sym = COD.findSymbol("foo", true); - EXPECT_TRUE(!!Sym) - << "CompileOnDemand::findSymbol should call findSymbol in the base layer."; + EXPECT_TRUE(!!Sym) << "CompileOnDemand::findSymbol should call findSymbol in " + "the base layer."; } - } diff --git a/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp b/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp index b2680aa7d8a..7d55641e4ce 100644 --- a/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp +++ b/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp @@ -19,7 +19,8 @@ using namespace llvm::orc::remote; class Queue : public std::queue { public: - std::mutex& getLock() { return Lock; } + std::mutex &getLock() { return Lock; } + private: std::mutex Lock; }; @@ -27,7 +28,7 @@ private: class QueueChannel : public RPCChannel { public: QueueChannel(Queue &InQueue, Queue &OutQueue) - : InQueue(InQueue), OutQueue(OutQueue) {} + : InQueue(InQueue), OutQueue(OutQueue) {} Error readBytes(char *Dst, unsigned Size) override { while (Size != 0) { @@ -60,10 +61,8 @@ private: Queue &OutQueue; }; -class DummyRPC : public testing::Test, - public RPC { +class DummyRPC : public testing::Test, public RPC { public: - enum FuncId : uint32_t { VoidBoolId = RPCFunctionIdTraits::FirstValidId, IntIntId, @@ -72,14 +71,12 @@ public: typedef Function VoidBool; typedef Function IntInt; - typedef Function)> - AllTheTypes; - + typedef Function)> + AllTheTypes; }; - TEST_F(DummyRPC, TestAsyncVoidBool) { Queue Q1, Q2; QueueChannel C1(Q1, Q2); @@ -91,12 +88,10 @@ TEST_F(DummyRPC, TestAsyncVoidBool) { { // Expect a call to Proc1. - auto EC = expect(C2, - [&](bool &B) { - EXPECT_EQ(B, true) - << "Bool serialization broken"; - return Error::success(); - }); + auto EC = expect(C2, [&](bool &B) { + EXPECT_EQ(B, true) << "Bool serialization broken"; + return Error::success(); + }); EXPECT_FALSE(EC) << "Simple expect over queue failed"; } @@ -122,12 +117,10 @@ TEST_F(DummyRPC, TestAsyncIntInt) { { // Expect a call to Proc1. - auto EC = expect(C2, - [&](int32_t I) -> Expected { - EXPECT_EQ(I, 21) - << "Bool serialization broken"; - return 2 * I; - }); + auto EC = expect(C2, [&](int32_t I) -> Expected { + EXPECT_EQ(I, 21) << "Bool serialization broken"; + return 2 * I; + }); EXPECT_FALSE(EC) << "Simple expect over queue failed"; } @@ -150,60 +143,32 @@ TEST_F(DummyRPC, TestSerialization) { // Make a call to Proc1. std::vector v({42, 7}); - auto ResOrErr = callAsyncWithSeq(C1, - -101, - 250, - -10000, - 10000, - -1000000000, - 1000000000, - -10000000000, - 10000000000, - true, - "foo", - v); - EXPECT_TRUE(!!ResOrErr) - << "Big (serialization test) call over queue failed"; + auto ResOrErr = callAsyncWithSeq( + C1, -101, 250, -10000, 10000, -1000000000, 1000000000, -10000000000, + 10000000000, true, "foo", v); + EXPECT_TRUE(!!ResOrErr) << "Big (serialization test) call over queue failed"; { // Expect a call to Proc1. - auto EC = expect(C2, - [&](int8_t &s8, - uint8_t &u8, - int16_t &s16, - uint16_t &u16, - int32_t &s32, - uint32_t &u32, - int64_t &s64, - uint64_t &u64, - bool &b, - std::string &s, - std::vector &v) { - - EXPECT_EQ(s8, -101) - << "int8_t serialization broken"; - EXPECT_EQ(u8, 250) - << "uint8_t serialization broken"; - EXPECT_EQ(s16, -10000) - << "int16_t serialization broken"; - EXPECT_EQ(u16, 10000) - << "uint16_t serialization broken"; - EXPECT_EQ(s32, -1000000000) - << "int32_t serialization broken"; - EXPECT_EQ(u32, 1000000000ULL) - << "uint32_t serialization broken"; - EXPECT_EQ(s64, -10000000000) - << "int64_t serialization broken"; - EXPECT_EQ(u64, 10000000000ULL) - << "uint64_t serialization broken"; - EXPECT_EQ(b, true) - << "bool serialization broken"; - EXPECT_EQ(s, "foo") - << "std::string serialization broken"; - EXPECT_EQ(v, std::vector({42, 7})) - << "std::vector serialization broken"; - return Error::success(); - }); + auto EC = expect( + C2, [&](int8_t &s8, uint8_t &u8, int16_t &s16, uint16_t &u16, + int32_t &s32, uint32_t &u32, int64_t &s64, uint64_t &u64, + bool &b, std::string &s, std::vector &v) { + + EXPECT_EQ(s8, -101) << "int8_t serialization broken"; + EXPECT_EQ(u8, 250) << "uint8_t serialization broken"; + EXPECT_EQ(s16, -10000) << "int16_t serialization broken"; + EXPECT_EQ(u16, 10000) << "uint16_t serialization broken"; + EXPECT_EQ(s32, -1000000000) << "int32_t serialization broken"; + EXPECT_EQ(u32, 1000000000ULL) << "uint32_t serialization broken"; + EXPECT_EQ(s64, -10000000000) << "int64_t serialization broken"; + EXPECT_EQ(u64, 10000000000ULL) << "uint64_t serialization broken"; + EXPECT_EQ(b, true) << "bool serialization broken"; + EXPECT_EQ(s, "foo") << "std::string serialization broken"; + EXPECT_EQ(v, std::vector({42, 7})) + << "std::vector serialization broken"; + return Error::success(); + }); EXPECT_FALSE(EC) << "Big (serialization test) call over queue failed"; } -- 2.11.0