mirror of
https://github.com/RPCSX/llvm.git
synced 2024-11-24 04:09:45 +00:00
[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
This commit is contained in:
Lang Hames
parent
02e4498043
commit
3869f2a5ab
@ -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.
|
||||
|
||||
@ -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(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.
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -327,25 +327,24 @@ template <typename ChannelT, typename FunctionIdT = uint32_t,
|
||||
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);
|
||||
|
||||
@ -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 <CBMgr>, %rdi
|
||||
// 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,
|
||||
// 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
|
||||
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,
|
||||
// 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
|
||||
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<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(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<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 *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 <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 *TrampolineMem, void *ResolverAddr,
|
||||
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(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<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;
|
||||
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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>>();
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@ -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<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).
|
||||
[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 (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);
|
||||
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 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;
|
||||
}
|
||||
|
||||
|
||||
@ -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));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -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, 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.";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -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) {
|
||||
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_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";
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user