[llvm] r267475 - [ORC] clang-format code that was touched in r267457. NFC.
Lang Hames via llvm-commits
llvm-commits at lists.llvm.org
Mon Apr 25 14:21:21 PDT 2016
Author: lhames
Date: Mon Apr 25 16:21:20 2016
New Revision: 267475
URL: http://llvm.org/viewvc/llvm-project?rev=267475&view=rev
Log:
[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.
Modified:
llvm/trunk/include/llvm-c/OrcBindings.h
llvm/trunk/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h
llvm/trunk/lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp
llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindings.cpp
llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp
llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
llvm/trunk/lib/ExecutionEngine/Orc/OrcError.cpp
llvm/trunk/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp
llvm/trunk/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp
Modified: llvm/trunk/include/llvm-c/OrcBindings.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm-c/OrcBindings.h?rev=267475&r1=267474&r2=267475&view=diff
==============================================================================
--- llvm/trunk/include/llvm-c/OrcBindings.h (original)
+++ llvm/trunk/include/llvm-c/OrcBindings.h Mon Apr 25 16:21:20 2016
@@ -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(LLVMOrcJITSta
/**
* 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.
Modified: llvm/trunk/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h?rev=267475&r1=267474&r2=267475&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h (original)
+++ llvm/trunk/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h Mon Apr 25 16:21:20 2016
@@ -29,7 +29,6 @@ namespace orc {
/// @brief Target-independent base class for compile callback management.
class JITCompileCallbackManager {
public:
-
typedef std::function<TargetAddress()> 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<TargetAddress> AvailableTrampolines;
private:
-
TargetAddress getAvailableTrampolineAddr() {
if (this->AvailableTrampolines.empty())
grow();
@@ -137,20 +138,17 @@ private:
template <typename TargetT>
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<uint8_t *>(ResolverBlock.base()),
@@ -163,13 +161,11 @@ public:
}
private:
-
static TargetAddress reenter(void *CCMgr, void *TrampolineId) {
JITCompileCallbackManager *Mgr =
- static_cast<JITCompileCallbackManager*>(CCMgr);
+ static_cast<JITCompileCallbackManager *>(CCMgr);
return Mgr->executeCompileCallback(
- static_cast<TargetAddress>(
- reinterpret_cast<uintptr_t>(TrampolineId)));
+ static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(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<uint8_t*>(TrampolineBlock.base());
+ uint8_t *TrampolineMem = static_cast<uint8_t *>(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<std::pair<TargetAddress, JITSymbolFlags>> 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 <typename TargetT>
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<TargetAddress>(reinterpret_cast<uintptr_t>(StubAddr));
+ static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(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<TargetAddress>(reinterpret_cast<uintptr_t>(PtrAddr));
+ static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(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<void*>(static_cast<uintptr_t>(NewAddr));
+ reinterpret_cast<void *>(static_cast<uintptr_t>(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<void*>(static_cast<uintptr_t>(InitAddr));
+ reinterpret_cast<void *>(static_cast<uintptr_t>(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(
/// 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, V
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(Globa
GlobalVariable *NewGV = nullptr);
/// @brief Clone
-GlobalAlias* cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA,
+GlobalAlias *cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA,
ValueToValueMapTy &VMap);
} // End namespace orc.
Modified: llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h?rev=267475&r1=267474&r2=267475&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h (original)
+++ llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h Mon Apr 25 16:21:20 2016
@@ -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<char*>(static_cast<uintptr_t>(Dst));
+ char *Addr = reinterpret_cast<char *>(static_cast<uintptr_t>(Dst));
DBW = DirectBufferWriter(0, Dst, Size);
@@ -65,7 +64,6 @@ inline Error deserialize(RPCChannel &C,
class OrcRemoteTargetRPCAPI : public RPC<RPCChannel> {
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<JITFuncId>::InvalidId,
@@ -127,80 +122,78 @@ public:
typedef Function<CallIntVoidId, int32_t(TargetAddress Addr)> CallIntVoid;
- typedef Function<CallMainId, int32_t(TargetAddress Addr,
- std::vector<std::string> Args)>
+ typedef Function<CallMainId,
+ int32_t(TargetAddress Addr, std::vector<std::string> Args)>
CallMain;
typedef Function<CallVoidVoidId, void(TargetAddress FnAddr)> CallVoidVoid;
typedef Function<CreateRemoteAllocatorId,
- void(ResourceIdMgr::ResourceId AllocatorID)>
+ void(ResourceIdMgr::ResourceId AllocatorID)>
CreateRemoteAllocator;
typedef Function<CreateIndirectStubsOwnerId,
- void(ResourceIdMgr::ResourceId StubOwnerID)>
- CreateIndirectStubsOwner;
+ void(ResourceIdMgr::ResourceId StubOwnerID)>
+ CreateIndirectStubsOwner;
typedef Function<DeregisterEHFramesId,
- void(TargetAddress Addr, uint32_t Size)>
+ void(TargetAddress Addr, uint32_t Size)>
DeregisterEHFrames;
typedef Function<DestroyRemoteAllocatorId,
- void(ResourceIdMgr::ResourceId AllocatorID)>
+ void(ResourceIdMgr::ResourceId AllocatorID)>
DestroyRemoteAllocator;
typedef Function<DestroyIndirectStubsOwnerId,
- void(ResourceIdMgr::ResourceId StubsOwnerID)>
+ void(ResourceIdMgr::ResourceId StubsOwnerID)>
DestroyIndirectStubsOwner;
/// EmitIndirectStubs result is (StubsBase, PtrsBase, NumStubsEmitted).
typedef Function<EmitIndirectStubsId,
- std::tuple<TargetAddress, TargetAddress, uint32_t>(
- ResourceIdMgr::ResourceId StubsOwnerID,
- uint32_t NumStubsRequired)>
+ std::tuple<TargetAddress, TargetAddress, uint32_t>(
+ ResourceIdMgr::ResourceId StubsOwnerID,
+ uint32_t NumStubsRequired)>
EmitIndirectStubs;
typedef Function<EmitResolverBlockId, void()> EmitResolverBlock;
/// EmitTrampolineBlock result is (BlockAddr, NumTrampolines).
- typedef Function<EmitTrampolineBlockId,
- std::tuple<TargetAddress, uint32_t>()> EmitTrampolineBlock;
+ typedef Function<EmitTrampolineBlockId, std::tuple<TargetAddress, uint32_t>()>
+ EmitTrampolineBlock;
typedef Function<GetSymbolAddressId, TargetAddress(std::string SymbolName)>
GetSymbolAddress;
/// GetRemoteInfo result is (Triple, PointerSize, PageSize, TrampolineSize,
/// IndirectStubsSize).
- typedef Function<GetRemoteInfoId,
- std::tuple<std::string, uint32_t, uint32_t, uint32_t,
- uint32_t>()> GetRemoteInfo;
+ typedef Function<GetRemoteInfoId, std::tuple<std::string, uint32_t, uint32_t,
+ uint32_t, uint32_t>()>
+ GetRemoteInfo;
typedef Function<ReadMemId,
- std::vector<char>(TargetAddress Src, uint64_t Size)>
+ std::vector<char>(TargetAddress Src, uint64_t Size)>
ReadMem;
- typedef Function<RegisterEHFramesId,
- void(TargetAddress Addr, uint32_t Size)>
+ typedef Function<RegisterEHFramesId, void(TargetAddress Addr, uint32_t Size)>
RegisterEHFrames;
typedef Function<ReserveMemId,
- TargetAddress(ResourceIdMgr::ResourceId AllocID,
- uint64_t Size, uint32_t Align)>
+ TargetAddress(ResourceIdMgr::ResourceId AllocID,
+ uint64_t Size, uint32_t Align)>
ReserveMem;
typedef Function<RequestCompileId,
- TargetAddress(TargetAddress TrampolineAddr)>
+ TargetAddress(TargetAddress TrampolineAddr)>
RequestCompile;
typedef Function<SetProtectionsId,
- void(ResourceIdMgr::ResourceId AllocID, TargetAddress Dst,
- uint32_t ProtFlags)>
+ void(ResourceIdMgr::ResourceId AllocID, TargetAddress Dst,
+ uint32_t ProtFlags)>
SetProtections;
typedef Function<TerminateSessionId, void()> TerminateSession;
- typedef Function<WriteMemId, void(DirectBufferWriter DB)>
- WriteMem;
+ typedef Function<WriteMemId, void(DirectBufferWriter DB)> WriteMem;
typedef Function<WritePtrId, void(TargetAddress Dst, TargetAddress Val)>
WritePtr;
Modified: llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h?rev=267475&r1=267474&r2=267475&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h (original)
+++ llvm/trunk/include/llvm/ExecutionEngine/Orc/RPCUtils.h Mon Apr 25 16:21:20 2016
@@ -327,25 +327,24 @@ template <typename ChannelT, typename Fu
typename SequenceNumberT = uint16_t>
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<Func>(std::move(Promise));
if (auto Err = CallHelper<ChannelT, SequenceNumberT, Func>::call(C, SeqNo,
- Args...)) {
+ Args...)) {
abandonOutstandingResults();
return std::move(Err);
} else
@@ -435,7 +434,7 @@ public:
/// std::future<Optional<T>> (or a future<bool> for void functions).
template <typename Func, typename... ArgTs>
Expected<AsyncCallResult<Func>> appendCallAsync(ChannelT &C,
- const ArgTs &... Args) {
+ const ArgTs &... Args) {
auto ResAndSeqOrErr = appendCallAsyncWithSeq<Func>(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 <typename Func, typename... ArgTs>
- Expected<AsyncCallResult<Func>> callAsync(ChannelT &C, const ArgTs &... Args) {
+ Expected<AsyncCallResult<Func>> callAsync(ChannelT &C,
+ const ArgTs &... Args) {
auto ResAndSeqOrErr = callAsyncWithSeq<Func>(C, Args...);
if (ResAndSeqOrErr)
return std::move(ResAndSeqOrErr->first);
Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp?rev=267475&r1=267474&r2=267475&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp Mon Apr 25 16:21:20 2016
@@ -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_
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 <CBMgr>, %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 <REntry>, %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 <CBMgr>, %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 <REntry>, %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_
}
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<uint64_t*>(TrampolineMem);
+ uint64_t *Trampolines = reinterpret_cast<uint64_t *>(TrampolineMem);
uint64_t CallIndirPCRel = 0xf1c40000000015ff;
for (unsigned I = 0; I < NumTrampolines; ++I, OffsetToPtr -= TrampolineSize)
@@ -126,36 +126,32 @@ Error OrcX86_64::emitIndirectStubsBlock(
// 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<char*>(StubsMem.base()) +
- NumPages * PageSize,
+ sys::MemoryBlock PtrsBlock(static_cast<char *>(StubsMem.base()) +
+ NumPages * PageSize,
NumPages * PageSize);
// Populate the stubs page stubs and mark it executable.
- uint64_t *Stub = reinterpret_cast<uint64_t*>(StubsBlock.base());
- uint64_t PtrOffsetField =
- static_cast<uint64_t>(NumPages * PageSize - 6) << 16;
+ uint64_t *Stub = reinterpret_cast<uint64_t *>(StubsBlock.base());
+ uint64_t PtrOffsetField = static_cast<uint64_t>(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<void**>(PtrsBlock.base());
+ void **Ptr = reinterpret_cast<void **>(PtrsBlock.base());
for (unsigned I = 0; I < NumStubs; ++I)
Ptr[I] = InitialPtrVal;
@@ -168,37 +164,38 @@ void OrcI386::writeResolverCode(uint8_t
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 <cbmgr>, (%esp)
- 0xb8, 0x00, 0x00, 0x00, 0x00, // 0x29: movl <reentry>, %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 <cbmgr>, (%esp)
+ 0xb8, 0x00, 0x00, 0x00, 0x00, // 0x29: movl <reentry>, %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 *
uint64_t CallRelImm = 0xF1C4C400000000e8;
uint64_t Resolver = reinterpret_cast<uint64_t>(ResolverAddr);
uint64_t ResolverRel =
- Resolver - reinterpret_cast<uint64_t>(TrampolineMem) - 5;
+ Resolver - reinterpret_cast<uint64_t>(TrampolineMem) - 5;
- uint64_t *Trampolines = reinterpret_cast<uint64_t*>(TrampolineMem);
+ uint64_t *Trampolines = reinterpret_cast<uint64_t *>(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(In
// 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<char*>(StubsMem.base()) +
- NumPages * PageSize,
+ sys::MemoryBlock PtrsBlock(static_cast<char *>(StubsMem.base()) +
+ NumPages * PageSize,
NumPages * PageSize);
// Populate the stubs page stubs and mark it executable.
- uint64_t *Stub = reinterpret_cast<uint64_t*>(StubsBlock.base());
+ uint64_t *Stub = reinterpret_cast<uint64_t *>(StubsBlock.base());
uint64_t PtrAddr = reinterpret_cast<uint64_t>(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<void**>(PtrsBlock.base());
+ void **Ptr = reinterpret_cast<void **>(PtrsBlock.base());
for (unsigned I = 0; I < NumStubs; ++I)
Ptr[I] = InitialPtrVal;
Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindings.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindings.cpp?rev=267475&r1=267474&r2=267475&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindings.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindings.cpp Mon Apr 25 16:21:20 2016
@@ -19,11 +19,10 @@ LLVMOrcJITStackRef LLVMOrcCreateInstance
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(LLVMOrcJITS
strcpy(*MangledName, Mangled.c_str());
}
-void LLVMOrcDisposeMangledSymbol(char *MangledName) {
- delete[] MangledName;
-}
+void LLVMOrcDisposeMangledSymbol(char *MangledName) { delete[] MangledName; }
LLVMOrcTargetAddress
LLVMOrcCreateLazyCompileCallback(LLVMOrcJITStackRef JITStack,
Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp?rev=267475&r1=267474&r2=267475&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp Mon Apr 25 16:21:20 2016
@@ -20,35 +20,36 @@ using namespace llvm;
std::unique_ptr<OrcCBindingsStack::CompileCallbackMgr>
OrcCBindingsStack::createCompileCallbackMgr(Triple T) {
switch (T.getArch()) {
- default: return nullptr;
+ default:
+ return nullptr;
- case Triple::x86: {
- typedef orc::LocalJITCompileCallbackManager<orc::OrcI386> CCMgrT;
- return llvm::make_unique<CCMgrT>(0);
- };
+ case Triple::x86: {
+ typedef orc::LocalJITCompileCallbackManager<orc::OrcI386> CCMgrT;
+ return llvm::make_unique<CCMgrT>(0);
+ };
- case Triple::x86_64: {
- typedef orc::LocalJITCompileCallbackManager<orc::OrcX86_64> CCMgrT;
- return llvm::make_unique<CCMgrT>(0);
- }
+ case Triple::x86_64: {
+ typedef orc::LocalJITCompileCallbackManager<orc::OrcX86_64> CCMgrT;
+ return llvm::make_unique<CCMgrT>(0);
+ }
}
}
OrcCBindingsStack::IndirectStubsManagerBuilder
OrcCBindingsStack::createIndirectStubsMgrBuilder(Triple T) {
switch (T.getArch()) {
- default: return nullptr;
+ default:
+ return nullptr;
- case Triple::x86:
- return [](){
- return llvm::make_unique<
- orc::LocalIndirectStubsManager<orc::OrcI386>>();
- };
+ case Triple::x86:
+ return []() {
+ return llvm::make_unique<orc::LocalIndirectStubsManager<orc::OrcI386>>();
+ };
- case Triple::x86_64:
- return [](){
- return llvm::make_unique<
- orc::LocalIndirectStubsManager<orc::OrcX86_64>>();
- };
+ case Triple::x86_64:
+ return []() {
+ return llvm::make_unique<
+ orc::LocalIndirectStubsManager<orc::OrcX86_64>>();
+ };
}
}
Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h?rev=267475&r1=267474&r2=267475&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h (original)
+++ llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h Mon Apr 25 16:21:20 2016
@@ -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(Targe
class OrcCBindingsStack {
public:
-
typedef orc::JITCompileCallbackManager CompileCallbackMgr;
typedef orc::ObjectLinkingLayer<> ObjLayerT;
typedef orc::IRCompileLayer<ObjLayerT> CompileLayerT;
- typedef orc::CompileOnDemandLayer<CompileLayerT, CompileCallbackMgr> CODLayerT;
+ typedef orc::CompileOnDemandLayer<CompileLayerT, CompileCallbackMgr>
+ CODLayerT;
typedef std::function<std::unique_ptr<CompileCallbackMgr>()>
- CallbackManagerBuilder;
+ CallbackManagerBuilder;
typedef CODLayerT::IndirectStubsManagerBuilderT IndirectStubsManagerBuilder;
private:
-
class GenericHandle {
public:
virtual ~GenericHandle() {}
@@ -50,20 +49,17 @@ private:
virtual void removeModule() = 0;
};
- template <typename LayerT>
- class GenericHandleImpl : public GenericHandle {
+ template <typename LayerT> 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<RuntimeDyld::SymbolResolver>(std::move(Resolver));
}
template <typename LayerT>
- ModuleHandleT addIRModule(LayerT &Layer,
- Module *M,
+ ModuleHandleT addIRModule(LayerT &Layer, Module *M,
std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr,
LLVMOrcSymbolResolverFn ExternalResolver,
void *ExternalResolverCtx) {
@@ -198,7 +188,7 @@ public:
auto Resolver = createResolver(ExternalResolver, ExternalResolverCtx);
// Add the module to the JIT.
- std::vector<Module*> S;
+ std::vector<Module *> 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<SectionMemoryManager>(),
+ llvm::make_unique<SectionMemoryManager>(),
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 <typename LayerT>
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;
}
Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcError.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcError.cpp?rev=267475&r1=267474&r2=267475&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/Orc/OrcError.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/Orc/OrcError.cpp Mon Apr 25 16:21:20 2016
@@ -53,8 +53,8 @@ namespace orc {
Error orcError(OrcErrorCode ErrCode) {
typedef std::underlying_type<OrcErrorCode>::type UT;
- return errorCodeToError(std::error_code(static_cast<UT>(ErrCode),
- *OrcErrCat));
+ return errorCodeToError(
+ std::error_code(static_cast<UT>(ErrCode), *OrcErrCat));
}
}
}
Modified: llvm/trunk/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp?rev=267475&r1=267474&r2=267475&view=diff
==============================================================================
--- llvm/trunk/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp (original)
+++ llvm/trunk/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp Mon Apr 25 16:21:20 2016
@@ -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<int>(DoNothingAndReturn<int>(0),
- DoNothingAndReturn<void>(),
- [](const std::string &Name, bool) {
- if (Name == "foo")
- return JITSymbol(1, JITSymbolFlags::Exported);
- return JITSymbol(nullptr);
- },
- DoNothingAndReturn<JITSymbol>(nullptr));
+ auto MockBaseLayer = createMockBaseLayer<int>(
+ DoNothingAndReturn<int>(0), DoNothingAndReturn<void>(),
+ [](const std::string &Name, bool) {
+ if (Name == "foo")
+ return JITSymbol(1, JITSymbolFlags::Exported);
+ return JITSymbol(nullptr);
+ },
+ DoNothingAndReturn<JITSymbol>(nullptr));
typedef decltype(MockBaseLayer) MockBaseLayerT;
DummyCallbackManager CallbackMgr;
@@ -68,8 +67,7 @@ TEST(CompileOnDemandLayerTest, FindSymbo
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.";
}
-
}
Modified: llvm/trunk/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp?rev=267475&r1=267474&r2=267475&view=diff
==============================================================================
--- llvm/trunk/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp (original)
+++ llvm/trunk/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp Mon Apr 25 16:21:20 2016
@@ -19,7 +19,8 @@ using namespace llvm::orc::remote;
class Queue : public std::queue<char> {
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<QueueChannel> {
+class DummyRPC : public testing::Test, public RPC<QueueChannel> {
public:
-
enum FuncId : uint32_t {
VoidBoolId = RPCFunctionIdTraits<FuncId>::FirstValidId,
IntIntId,
@@ -72,14 +71,12 @@ public:
typedef Function<VoidBoolId, void(bool)> VoidBool;
typedef Function<IntIntId, int32_t(int32_t)> IntInt;
- typedef Function<AllTheTypesId, void(int8_t, uint8_t, int16_t, uint16_t,
- int32_t, uint32_t, int64_t, uint64_t,
- bool, std::string, std::vector<int>)>
- AllTheTypes;
-
+ typedef Function<AllTheTypesId,
+ void(int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t,
+ int64_t, uint64_t, bool, std::string, std::vector<int>)>
+ 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<VoidBool>(C2,
- [&](bool &B) {
- EXPECT_EQ(B, true)
- << "Bool serialization broken";
- return Error::success();
- });
+ auto EC = expect<VoidBool>(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<IntInt>(C2,
- [&](int32_t I) -> Expected<int32_t> {
- EXPECT_EQ(I, 21)
- << "Bool serialization broken";
- return 2 * I;
- });
+ auto EC = expect<IntInt>(C2, [&](int32_t I) -> Expected<int32_t> {
+ 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<int> v({42, 7});
- auto ResOrErr = callAsyncWithSeq<AllTheTypes>(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<AllTheTypes>(
+ 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<AllTheTypes>(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<int> &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<int>({42, 7}))
- << "std::vector serialization broken";
- return Error::success();
- });
+ auto EC = expect<AllTheTypes>(
+ 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<int> &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<int>({42, 7}))
+ << "std::vector serialization broken";
+ return Error::success();
+ });
EXPECT_FALSE(EC) << "Big (serialization test) call over queue failed";
}
More information about the llvm-commits
mailing list