[llvm] r251933 - [Orc] Directly emit machine code for the x86 resolver block and trampolines.
Lang Hames via llvm-commits
llvm-commits at lists.llvm.org
Tue Nov 3 08:10:19 PST 2015
Author: lhames
Date: Tue Nov 3 10:10:18 2015
New Revision: 251933
URL: http://llvm.org/viewvc/llvm-project?rev=251933&view=rev
Log:
[Orc] Directly emit machine code for the x86 resolver block and trampolines.
Bypassing LLVM for this has a number of benefits:
1) Laziness support becomes asm-syntax agnostic (previously lazy jitting didn't
work on Windows as the resolver block was in Darwin asm).
2) For cross-process JITs, it allows resolver blocks and trampolines to be
emitted directly in the target process, reducing cross process traffic.
3) It should be marginally faster.
Modified:
llvm/trunk/include/llvm-c/OrcBindings.h
llvm/trunk/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h
llvm/trunk/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcTargetSupport.h
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/OrcTargetSupport.cpp
llvm/trunk/tools/lli/OrcLazyJIT.cpp
llvm/trunk/tools/lli/OrcLazyJIT.h
llvm/trunk/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp
llvm/trunk/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp
Modified: llvm/trunk/include/llvm-c/OrcBindings.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm-c/OrcBindings.h?rev=251933&r1=251932&r2=251933&view=diff
==============================================================================
--- llvm/trunk/include/llvm-c/OrcBindings.h (original)
+++ llvm/trunk/include/llvm-c/OrcBindings.h Tue Nov 3 10:10:18 2015
@@ -47,8 +47,7 @@ typedef uint64_t (*LLVMOrcLazyCompileCal
* client should not attempt to dispose of the Target Machine, or it will result
* in a double-free.
*/
-LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM,
- LLVMContextRef Context);
+LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM);
/**
* Mangle the given symbol.
Modified: llvm/trunk/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h?rev=251933&r1=251932&r2=251933&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h (original)
+++ llvm/trunk/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h Tue Nov 3 10:10:18 2015
@@ -242,7 +242,7 @@ private:
// Create a callback, associate it with the stub for the function,
// and set the compile action to compile the partition containing the
// function.
- auto CCInfo = CompileCallbackMgr.getCompileCallback(SrcM.getContext());
+ auto CCInfo = CompileCallbackMgr.getCompileCallback();
StubInits[mangle(F.getName(), DL)] =
std::make_pair(CCInfo.getAddress(),
JITSymbolBase::flagsFromGlobalValue(F));
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=251933&r1=251932&r2=251933&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h (original)
+++ llvm/trunk/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h Tue Nov 3 10:10:18 2015
@@ -27,8 +27,7 @@
namespace llvm {
namespace orc {
-/// @brief Base class for JITLayer independent aspects of
-/// JITCompileCallbackManager.
+/// @brief Target-independent base class JITCompileCallbackManager.
class JITCompileCallbackManagerBase {
public:
@@ -54,13 +53,8 @@ public:
/// @brief Construct a JITCompileCallbackManagerBase.
/// @param ErrorHandlerAddress The address of an error handler in the target
/// process to be used if a compile callback fails.
- /// @param NumTrampolinesPerBlock Number of trampolines to emit if there is no
- /// available trampoline when getCompileCallback is
- /// called.
- JITCompileCallbackManagerBase(TargetAddress ErrorHandlerAddress,
- unsigned NumTrampolinesPerBlock)
- : ErrorHandlerAddress(ErrorHandlerAddress),
- NumTrampolinesPerBlock(NumTrampolinesPerBlock) {}
+ JITCompileCallbackManagerBase(TargetAddress ErrorHandlerAddress)
+ : ErrorHandlerAddress(ErrorHandlerAddress) {}
virtual ~JITCompileCallbackManagerBase() {}
@@ -90,7 +84,7 @@ public:
}
/// @brief Reserve a compile callback.
- virtual CompileCallbackInfo getCompileCallback(LLVMContext &Context) = 0;
+ virtual CompileCallbackInfo getCompileCallback() = 0;
/// @brief Get a CompileCallbackInfo for an existing callback.
CompileCallbackInfo getCompileCallbackInfo(TargetAddress TrampolineAddr) {
@@ -113,7 +107,6 @@ public:
protected:
TargetAddress ErrorHandlerAddress;
- unsigned NumTrampolinesPerBlock;
typedef std::map<TargetAddress, CompileFtor> TrampolineMapT;
TrampolineMapT ActiveTrampolines;
@@ -124,69 +117,54 @@ private:
};
/// @brief Manage compile callbacks.
-template <typename JITLayerT, typename TargetT>
+template <typename TargetT>
class JITCompileCallbackManager : public JITCompileCallbackManagerBase {
public:
/// @brief Construct a JITCompileCallbackManager.
- /// @param JIT JIT layer to emit callback trampolines, etc. into.
- /// @param Context LLVMContext to use for trampoline & resolve block modules.
/// @param ErrorHandlerAddress The address of an error handler in the target
/// process to be used if a compile callback fails.
- /// @param NumTrampolinesPerBlock Number of trampolines to allocate whenever
- /// there is no existing callback trampoline.
- /// (Trampolines are allocated in blocks for
- /// efficiency.)
- JITCompileCallbackManager(JITLayerT &JIT, RuntimeDyld::MemoryManager &MemMgr,
- LLVMContext &Context,
- TargetAddress ErrorHandlerAddress,
- unsigned NumTrampolinesPerBlock)
- : JITCompileCallbackManagerBase(ErrorHandlerAddress,
- NumTrampolinesPerBlock),
- JIT(JIT), MemMgr(MemMgr) {
- emitResolverBlock(Context);
+ JITCompileCallbackManager(TargetAddress ErrorHandlerAddress)
+ : JITCompileCallbackManagerBase(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));
+ assert(!EC && "Failed to allocate resolver block");
+
+ TargetT::writeResolverCode(static_cast<uint8_t*>(ResolverBlock.base()),
+ &reenter, this);
+
+ EC = sys::Memory::protectMappedMemory(ResolverBlock.getMemoryBlock(),
+ sys::Memory::MF_READ |
+ sys::Memory::MF_EXEC);
+ assert(!EC && "Failed to mprotect resolver block");
}
/// @brief Get/create a compile callback with the given signature.
- CompileCallbackInfo getCompileCallback(LLVMContext &Context) final {
- TargetAddress TrampolineAddr = getAvailableTrampolineAddr(Context);
+ CompileCallbackInfo getCompileCallback() final {
+ TargetAddress TrampolineAddr = getAvailableTrampolineAddr();
auto &Compile = this->ActiveTrampolines[TrampolineAddr];
return CompileCallbackInfo(TrampolineAddr, Compile);
}
private:
- std::vector<std::unique_ptr<Module>>
- SingletonSet(std::unique_ptr<Module> M) {
- std::vector<std::unique_ptr<Module>> Ms;
- Ms.push_back(std::move(M));
- return Ms;
- }
-
- void emitResolverBlock(LLVMContext &Context) {
- std::unique_ptr<Module> M(new Module("resolver_block_module",
- Context));
- TargetT::insertResolverBlock(*M, *this);
- auto NonResolver =
- createLambdaResolver(
- [](const std::string &Name) -> RuntimeDyld::SymbolInfo {
- llvm_unreachable("External symbols in resolver block?");
- },
- [](const std::string &Name) -> RuntimeDyld::SymbolInfo {
- llvm_unreachable("Dylib symbols in resolver block?");
- });
- auto H = JIT.addModuleSet(SingletonSet(std::move(M)), &MemMgr,
- std::move(NonResolver));
- JIT.emitAndFinalize(H);
- auto ResolverBlockSymbol =
- JIT.findSymbolIn(H, TargetT::ResolverBlockName, false);
- assert(ResolverBlockSymbol && "Failed to insert resolver block");
- ResolverBlockAddr = ResolverBlockSymbol.getAddress();
+ static TargetAddress reenter(void *CCMgr, void *TrampolineId) {
+ JITCompileCallbackManager *Mgr =
+ static_cast<JITCompileCallbackManager*>(CCMgr);
+ return Mgr->executeCompileCallback(
+ static_cast<TargetAddress>(
+ reinterpret_cast<uintptr_t>(TrampolineId)));
}
- TargetAddress getAvailableTrampolineAddr(LLVMContext &Context) {
+ TargetAddress getAvailableTrampolineAddr() {
if (this->AvailableTrampolines.empty())
- grow(Context);
+ grow();
assert(!this->AvailableTrampolines.empty() &&
"Failed to grow available trampolines.");
TargetAddress TrampolineAddr = this->AvailableTrampolines.back();
@@ -194,35 +172,41 @@ private:
return TrampolineAddr;
}
- void grow(LLVMContext &Context) {
+ void grow() {
assert(this->AvailableTrampolines.empty() && "Growing prematurely?");
- std::unique_ptr<Module> M(new Module("trampoline_block", Context));
- auto GetLabelName =
- TargetT::insertCompileCallbackTrampolines(*M, ResolverBlockAddr,
- this->NumTrampolinesPerBlock,
- this->ActiveTrampolines.size());
- auto NonResolver =
- createLambdaResolver(
- [](const std::string &Name) -> RuntimeDyld::SymbolInfo {
- llvm_unreachable("External symbols in trampoline block?");
- },
- [](const std::string &Name) -> RuntimeDyld::SymbolInfo {
- llvm_unreachable("Dylib symbols in trampoline block?");
- });
- auto H = JIT.addModuleSet(SingletonSet(std::move(M)), &MemMgr,
- std::move(NonResolver));
- JIT.emitAndFinalize(H);
- for (unsigned I = 0; I < this->NumTrampolinesPerBlock; ++I) {
- std::string Name = GetLabelName(I);
- auto TrampolineSymbol = JIT.findSymbolIn(H, Name, false);
- assert(TrampolineSymbol && "Failed to emit trampoline.");
- this->AvailableTrampolines.push_back(TrampolineSymbol.getAddress());
- }
+
+ std::error_code EC;
+ auto TrampolineBlock =
+ sys::OwningMemoryBlock(
+ sys::Memory::allocateMappedMemory(TargetT::PageSize, nullptr,
+ sys::Memory::MF_READ |
+ sys::Memory::MF_WRITE, EC));
+ assert(!EC && "Failed to allocate trampoline block");
+
+
+ unsigned NumTrampolines =
+ (TargetT::PageSize - TargetT::PointerSize) / TargetT::TrampolineSize;
+
+ uint8_t *TrampolineMem = static_cast<uint8_t*>(TrampolineBlock.base());
+ TargetT::writeTrampolines(TrampolineMem, ResolverBlock.base(),
+ NumTrampolines);
+
+ for (unsigned I = 0; I < NumTrampolines; ++I)
+ this->AvailableTrampolines.push_back(
+ static_cast<TargetAddress>(
+ reinterpret_cast<uintptr_t>(
+ TrampolineMem + (I * TargetT::TrampolineSize))));
+
+ EC = sys::Memory::protectMappedMemory(TrampolineBlock.getMemoryBlock(),
+ sys::Memory::MF_READ |
+ sys::Memory::MF_EXEC);
+ assert(!EC && "Failed to mprotect trampoline block");
+
+ TrampolineBlocks.push_back(std::move(TrampolineBlock));
}
- JITLayerT &JIT;
- RuntimeDyld::MemoryManager &MemMgr;
- TargetAddress ResolverBlockAddr;
+ sys::OwningMemoryBlock ResolverBlock;
+ std::vector<sys::OwningMemoryBlock> TrampolineBlocks;
};
/// @brief Base class for managing collections of named indirect stubs.
Modified: llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcTargetSupport.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcTargetSupport.h?rev=251933&r1=251932&r2=251933&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcTargetSupport.h (original)
+++ llvm/trunk/include/llvm/ExecutionEngine/Orc/OrcTargetSupport.h Tue Nov 3 10:10:18 2015
@@ -26,29 +26,24 @@ namespace orc {
class OrcX86_64 {
public:
- static const char *ResolverBlockName;
+ static const unsigned PageSize = 4096;
+ static const unsigned PointerSize = 8;
+ static const unsigned TrampolineSize = 8;
+ static const unsigned ResolverCodeSize = 0x78;
- /// @brief Insert module-level inline callback asm into module M for the
- /// symbols managed by JITResolveCallbackHandler J.
- static void insertResolverBlock(Module &M,
- JITCompileCallbackManagerBase &JCBM);
+ typedef TargetAddress (*JITReentryFn)(void *CallbackMgr,
+ void *TrampolineId);
- /// @brief Get a label name from the given index.
- typedef std::function<std::string(unsigned)> LabelNameFtor;
+ /// @brief Write the resolver code into the given memory. The user is be
+ /// responsible for allocating the memory and setting permissions.
+ static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,
+ void *CallbackMgr);
- /// @brief Insert the requested number of trampolines into the given module.
- /// @param M Module to insert the call block into.
- /// @param NumCalls Number of calls to create in the call block.
- /// @param StartIndex Optional argument specifying the index suffix to start
- /// with.
- /// @return A functor that provides the symbol name for each entry in the call
- /// block.
- ///
- static LabelNameFtor insertCompileCallbackTrampolines(
- Module &M,
- TargetAddress TrampolineAddr,
- unsigned NumCalls,
- unsigned StartIndex = 0);
+ /// @brief Write the requsted number of trampolines into the given memory,
+ /// which must be big enough to hold 1 pointer, plus NumTrampolines
+ /// trampolines.
+ static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,
+ unsigned NumTrampolines);
/// @brief Provide information about stub blocks generated by the
/// makeIndirectStubsBlock function.
Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindings.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindings.cpp?rev=251933&r1=251932&r2=251933&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindings.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindings.cpp Tue Nov 3 10:10:18 2015
@@ -12,20 +12,18 @@
using namespace llvm;
-LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM,
- LLVMContextRef Context) {
+LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM) {
TargetMachine *TM2(unwrap(TM));
- LLVMContext &Ctx = *unwrap(Context);
Triple T(TM2->getTargetTriple());
- auto CallbackMgrBuilder = OrcCBindingsStack::createCallbackManagerBuilder(T);
+ auto CompileCallbackMgr = OrcCBindingsStack::createCompileCallbackMgr(T);
auto IndirectStubsMgrBuilder =
OrcCBindingsStack::createIndirectStubsMgrBuilder(T);
OrcCBindingsStack *JITStack =
- new OrcCBindingsStack(*TM2, Ctx, CallbackMgrBuilder,
- IndirectStubsMgrBuilder);
+ new OrcCBindingsStack(*TM2, std::move(CompileCallbackMgr),
+ IndirectStubsMgrBuilder);
return wrap(JITStack);
}
Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp?rev=251933&r1=251932&r2=251933&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp Tue Nov 3 10:10:18 2015
@@ -17,19 +17,14 @@
using namespace llvm;
-OrcCBindingsStack::CallbackManagerBuilder
-OrcCBindingsStack::createCallbackManagerBuilder(Triple T) {
+std::unique_ptr<OrcCBindingsStack::CompileCallbackMgr>
+OrcCBindingsStack::createCompileCallbackMgr(Triple T) {
switch (T.getArch()) {
default: return nullptr;
case Triple::x86_64: {
- typedef orc::JITCompileCallbackManager<CompileLayerT,
- orc::OrcX86_64> CCMgrT;
- return [](CompileLayerT &CompileLayer, RuntimeDyld::MemoryManager &MemMgr,
- LLVMContext &Context) {
- return llvm::make_unique<CCMgrT>(CompileLayer, MemMgr, Context, 0,
- 64);
- };
+ typedef orc::JITCompileCallbackManager<orc::OrcX86_64> CCMgrT;
+ return llvm::make_unique<CCMgrT>(0);
}
}
}
Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h?rev=251933&r1=251932&r2=251933&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h (original)
+++ llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h Tue Nov 3 10:10:18 2015
@@ -34,10 +34,7 @@ public:
typedef orc::IRCompileLayer<ObjLayerT> CompileLayerT;
typedef orc::CompileOnDemandLayer<CompileLayerT, CompileCallbackMgr> CODLayerT;
- typedef std::function<
- std::unique_ptr<CompileCallbackMgr>(CompileLayerT&,
- RuntimeDyld::MemoryManager&,
- LLVMContext&)>
+ typedef std::function<std::unique_ptr<CompileCallbackMgr>()>
CallbackManagerBuilder;
typedef CODLayerT::IndirectStubsManagerBuilderT IndirectStubsManagerBuilder;
@@ -86,19 +83,18 @@ public:
typedef unsigned ModuleHandleT;
- static CallbackManagerBuilder createCallbackManagerBuilder(Triple T);
+ static std::unique_ptr<CompileCallbackMgr> createCompileCallbackMgr(Triple T);
static IndirectStubsManagerBuilder createIndirectStubsMgrBuilder(Triple T);
- OrcCBindingsStack(TargetMachine &TM, LLVMContext &Context,
- CallbackManagerBuilder &BuildCallbackMgr,
+ OrcCBindingsStack(TargetMachine &TM,
+ std::unique_ptr<CompileCallbackMgr> CCMgr,
IndirectStubsManagerBuilder IndirectStubsMgrBuilder)
- : Context(Context), DL(TM.createDataLayout()),
+ : DL(TM.createDataLayout()), CCMgr(std::move(CCMgr)),
ObjectLayer(),
CompileLayer(ObjectLayer, orc::SimpleCompiler(TM)),
- CCMgr(BuildCallbackMgr(CompileLayer, CCMgrMemMgr, Context)),
CODLayer(CompileLayer,
[](Function &F) { std::set<Function*> S; S.insert(&F); return S; },
- *CCMgr, std::move(IndirectStubsMgrBuilder), false),
+ *this->CCMgr, std::move(IndirectStubsMgrBuilder), false),
IndirectStubsMgr(IndirectStubsMgrBuilder()),
CXXRuntimeOverrides([this](const std::string &S) { return mangle(S); }) {}
@@ -127,7 +123,7 @@ public:
orc::TargetAddress
createLazyCompileCallback(LLVMOrcLazyCompileCallbackFn Callback,
void *CallbackCtx) {
- auto CCInfo = CCMgr->getCompileCallback(Context);
+ auto CCInfo = CCMgr->getCompileCallback();
CCInfo.setCompileAction(
[=]() -> orc::TargetAddress {
return Callback(wrap(this), CallbackCtx);
@@ -264,13 +260,12 @@ private:
return NewHandle;
}
- LLVMContext &Context;
DataLayout DL;
SectionMemoryManager CCMgrMemMgr;
+ std::unique_ptr<CompileCallbackMgr> CCMgr;
ObjLayerT ObjectLayer;
CompileLayerT CompileLayer;
- std::unique_ptr<CompileCallbackMgr> CCMgr;
CODLayerT CODLayer;
std::unique_ptr<orc::IndirectStubsManagerBase> IndirectStubsMgr;
Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcTargetSupport.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcTargetSupport.cpp?rev=251933&r1=251932&r2=251933&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/Orc/OrcTargetSupport.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/Orc/OrcTargetSupport.cpp Tue Nov 3 10:10:18 2015
@@ -12,136 +12,88 @@
#include "llvm/Support/Process.h"
#include <array>
-using namespace llvm::orc;
-
-namespace {
-
-uint64_t executeCompileCallback(JITCompileCallbackManagerBase *JCBM,
- TargetAddress CallbackID) {
- return JCBM->executeCompileCallback(CallbackID);
-}
-
-}
-
namespace llvm {
namespace orc {
-const char* OrcX86_64::ResolverBlockName = "orc_resolver_block";
+void OrcX86_64::writeResolverCode(uint8_t *ResolverMem, JITReentryFn ReentryFn,
+ void *CallbackMgr) {
-void OrcX86_64::insertResolverBlock(
- Module &M, JITCompileCallbackManagerBase &JCBM) {
+ 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 20, %rsp
+ 0x48, 0x0f, 0xae, 0x04, 0x24, // 0x21: fxsave64 (%rsp)
+ 0x48, 0x8d, 0x3d, 0x43, 0x00, 0x00, 0x00, // 0x26: leaq 67(%rip), %rdi
+ 0x48, 0x8b, 0x3f, // 0x2d: movq (%rdi), %rdi
+ 0x48, 0x8b, 0x75, 0x08, // 0x30: movq 8(%rbp), %rsi
+ 0x48, 0x83, 0xee, 0x06, // 0x34: subq $6, %rsi
+ 0x48, 0xb8, // 0x38: movabsq $0, %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 20, %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
+ 0x00, 0x00, 0x00, 0x00, // 0x6c: <padding>
- // Trampoline code-sequence length, used to get trampoline address from return
- // address.
- const unsigned X86_64_TrampolineLength = 6;
-
- // List of x86-64 GPRs to save. Note - RBP saved separately below.
- std::array<const char *, 14> GPRs = {{
- "rax", "rbx", "rcx", "rdx",
- "rsi", "rdi", "r8", "r9",
- "r10", "r11", "r12", "r13",
- "r14", "r15"
- }};
-
- // Address of the executeCompileCallback function.
- uint64_t CallbackAddr =
- static_cast<uint64_t>(
- reinterpret_cast<uintptr_t>(executeCompileCallback));
-
- std::ostringstream AsmStream;
- Triple TT(M.getTargetTriple());
-
- // Switch to text section.
- if (TT.getOS() == Triple::Darwin)
- AsmStream << ".section __TEXT,__text,regular,pure_instructions\n"
- << ".align 4, 0x90\n";
- else
- AsmStream << ".text\n"
- << ".align 16, 0x90\n";
-
- // Bake in a pointer to the callback manager immediately before the
- // start of the resolver function.
- AsmStream << "jit_callback_manager_addr:\n"
- << " .quad " << &JCBM << "\n";
-
- // Start the resolver function.
- AsmStream << ResolverBlockName << ":\n"
- << " pushq %rbp\n"
- << " movq %rsp, %rbp\n";
-
- // Store the GPRs.
- for (const auto &GPR : GPRs)
- AsmStream << " pushq %" << GPR << "\n";
-
- // Store floating-point state with FXSAVE.
- // Note: We need to keep the stack 16-byte aligned, so if we've emitted an odd
- // number of 64-bit pushes so far (GPRs.size() plus 1 for RBP) then add
- // an extra 64 bits of padding to the FXSave area.
- unsigned Padding = (GPRs.size() + 1) % 2 ? 8 : 0;
- unsigned FXSaveSize = 512 + Padding;
- AsmStream << " subq $" << FXSaveSize << ", %rsp\n"
- << " fxsave64 (%rsp)\n"
-
- // Load callback manager address, compute trampoline address, call JIT.
- << " lea jit_callback_manager_addr(%rip), %rdi\n"
- << " movq (%rdi), %rdi\n"
- << " movq 0x8(%rbp), %rsi\n"
- << " subq $" << X86_64_TrampolineLength << ", %rsi\n"
- << " movabsq $" << CallbackAddr << ", %rax\n"
- << " callq *%rax\n"
-
- // Replace the return to the trampoline with the return address of the
- // compiled function body.
- << " movq %rax, 0x8(%rbp)\n"
-
- // Restore the floating point state.
- << " fxrstor64 (%rsp)\n"
- << " addq $" << FXSaveSize << ", %rsp\n";
-
- for (const auto &GPR : make_range(GPRs.rbegin(), GPRs.rend()))
- AsmStream << " popq %" << GPR << "\n";
-
- // Restore original RBP and return to compiled function body.
- AsmStream << " popq %rbp\n"
- << " retq\n";
+ // 0x70: Callback mgr address.
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ };
- M.appendModuleInlineAsm(AsmStream.str());
+ const unsigned ReentryFnAddrOffset = 0x3a;
+ const unsigned CallbackMgrAddrOffset = 0x70;
+
+ memcpy(ResolverMem, ResolverCode, sizeof(ResolverCode));
+ memcpy(ResolverMem + ReentryFnAddrOffset, &ReentryFn, sizeof(ReentryFn));
+ memcpy(ResolverMem + CallbackMgrAddrOffset, &CallbackMgr,
+ sizeof(CallbackMgr));
}
-OrcX86_64::LabelNameFtor
-OrcX86_64::insertCompileCallbackTrampolines(Module &M,
- TargetAddress ResolverBlockAddr,
- unsigned NumCalls,
- unsigned StartIndex) {
- const char *ResolverBlockPtrName = "Lorc_resolve_block_addr";
-
- std::ostringstream AsmStream;
- Triple TT(M.getTargetTriple());
-
- if (TT.getOS() == Triple::Darwin)
- AsmStream << ".section __TEXT,__text,regular,pure_instructions\n"
- << ".align 4, 0x90\n";
- else
- AsmStream << ".text\n"
- << ".align 16, 0x90\n";
-
- AsmStream << ResolverBlockPtrName << ":\n"
- << " .quad " << ResolverBlockAddr << "\n";
-
- auto GetLabelName =
- [=](unsigned I) {
- std::ostringstream LabelStream;
- LabelStream << "orc_jcc_" << (StartIndex + I);
- return LabelStream.str();
- };
+void OrcX86_64::writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,
+ unsigned NumTrampolines) {
+
+ unsigned OffsetToPtr = NumTrampolines * TrampolineSize;
- for (unsigned I = 0; I < NumCalls; ++I)
- AsmStream << GetLabelName(I) << ":\n"
- << " callq *" << ResolverBlockPtrName << "(%rip)\n";
+ memcpy(TrampolineMem + OffsetToPtr, &ResolverAddr, sizeof(void*));
- M.appendModuleInlineAsm(AsmStream.str());
+ uint64_t *Trampolines = reinterpret_cast<uint64_t*>(TrampolineMem);
+ uint64_t CallIndirPCRel = 0xf1c40000000015ff;
- return GetLabelName;
+ for (unsigned I = 0; I < NumTrampolines; ++I, OffsetToPtr -= TrampolineSize)
+ Trampolines[I] = CallIndirPCRel | ((OffsetToPtr - 6) << 16);
}
std::error_code OrcX86_64::emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,
Modified: llvm/trunk/tools/lli/OrcLazyJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/lli/OrcLazyJIT.cpp?rev=251933&r1=251932&r2=251933&view=diff
==============================================================================
--- llvm/trunk/tools/lli/OrcLazyJIT.cpp (original)
+++ llvm/trunk/tools/lli/OrcLazyJIT.cpp Tue Nov 3 10:10:18 2015
@@ -46,19 +46,14 @@ namespace {
cl::init(true), cl::Hidden);
}
-OrcLazyJIT::CallbackManagerBuilder
-OrcLazyJIT::createCallbackMgrBuilder(Triple T) {
+std::unique_ptr<OrcLazyJIT::CompileCallbackMgr>
+OrcLazyJIT::createCompileCallbackMgr(Triple T) {
switch (T.getArch()) {
default: return nullptr;
case Triple::x86_64: {
- typedef orc::JITCompileCallbackManager<IRDumpLayerT,
- orc::OrcX86_64> CCMgrT;
- return [](IRDumpLayerT &IRDumpLayer, RuntimeDyld::MemoryManager &MemMgr,
- LLVMContext &Context) {
- return llvm::make_unique<CCMgrT>(IRDumpLayer, MemMgr, Context, 0,
- 64);
- };
+ typedef orc::JITCompileCallbackManager<orc::OrcX86_64> CCMgrT;
+ return llvm::make_unique<CCMgrT>(0);
}
}
}
@@ -146,13 +141,12 @@ int llvm::runOrcLazyJIT(std::unique_ptr<
EngineBuilder EB;
EB.setOptLevel(getOptLevel());
auto TM = std::unique_ptr<TargetMachine>(EB.selectTarget());
- auto &Context = getGlobalContext();
- auto CallbackMgrBuilder =
- OrcLazyJIT::createCallbackMgrBuilder(Triple(TM->getTargetTriple()));
+ auto CompileCallbackMgr =
+ OrcLazyJIT::createCompileCallbackMgr(Triple(TM->getTargetTriple()));
// If we couldn't build the factory function then there must not be a callback
// manager for this target. Bail out.
- if (!CallbackMgrBuilder) {
+ if (!CompileCallbackMgr) {
errs() << "No callback manager available for target '"
<< TM->getTargetTriple().str() << "'.\n";
return 1;
@@ -169,7 +163,7 @@ int llvm::runOrcLazyJIT(std::unique_ptr<
}
// Everything looks good. Build the JIT.
- OrcLazyJIT J(std::move(TM), Context, CallbackMgrBuilder,
+ OrcLazyJIT J(std::move(TM), std::move(CompileCallbackMgr),
std::move(IndirectStubsMgrBuilder),
OrcInlineStubs);
Modified: llvm/trunk/tools/lli/OrcLazyJIT.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/lli/OrcLazyJIT.h?rev=251933&r1=251932&r2=251933&view=diff
==============================================================================
--- llvm/trunk/tools/lli/OrcLazyJIT.h (original)
+++ llvm/trunk/tools/lli/OrcLazyJIT.h Tue Nov 3 10:10:18 2015
@@ -23,7 +23,6 @@
#include "llvm/ExecutionEngine/Orc/IRTransformLayer.h"
#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
#include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
-#include "llvm/IR/LLVMContext.h"
namespace llvm {
@@ -41,21 +40,16 @@ public:
IndirectStubsManagerBuilder;
typedef CODLayerT::ModuleSetHandleT ModuleHandleT;
- typedef std::function<
- std::unique_ptr<CompileCallbackMgr>(IRDumpLayerT&,
- RuntimeDyld::MemoryManager&,
- LLVMContext&)>
- CallbackManagerBuilder;
-
- OrcLazyJIT(std::unique_ptr<TargetMachine> TM, LLVMContext &Context,
- CallbackManagerBuilder &BuildCallbackMgr,
+ OrcLazyJIT(std::unique_ptr<TargetMachine> TM,
+ std::unique_ptr<CompileCallbackMgr> CCMgr,
IndirectStubsManagerBuilder IndirectStubsMgrBuilder,
bool InlineStubs)
- : TM(std::move(TM)), DL(this->TM->createDataLayout()), ObjectLayer(),
+ : TM(std::move(TM)), DL(this->TM->createDataLayout()),
+ CCMgr(std::move(CCMgr)),
+ ObjectLayer(),
CompileLayer(ObjectLayer, orc::SimpleCompiler(*this->TM)),
IRDumpLayer(CompileLayer, createDebugDumper()),
- CCMgr(BuildCallbackMgr(IRDumpLayer, CCMgrMemMgr, Context)),
- CODLayer(IRDumpLayer, extractSingleFunction, *CCMgr,
+ CODLayer(IRDumpLayer, extractSingleFunction, *this->CCMgr,
std::move(IndirectStubsMgrBuilder), InlineStubs),
CXXRuntimeOverrides(
[this](const std::string &S) { return mangle(S); }) {}
@@ -68,8 +62,7 @@ public:
DtorRunner.runViaLayer(CODLayer);
}
- static CallbackManagerBuilder createCallbackMgrBuilder(Triple T);
-
+ static std::unique_ptr<CompileCallbackMgr> createCompileCallbackMgr(Triple T);
static IndirectStubsManagerBuilder createIndirectStubsMgrBuilder(Triple T);
ModuleHandleT addModule(std::unique_ptr<Module> M) {
@@ -155,10 +148,10 @@ private:
DataLayout DL;
SectionMemoryManager CCMgrMemMgr;
+ std::unique_ptr<CompileCallbackMgr> CCMgr;
ObjLayerT ObjectLayer;
CompileLayerT CompileLayer;
IRDumpLayerT IRDumpLayer;
- std::unique_ptr<CompileCallbackMgr> CCMgr;
CODLayerT CODLayer;
orc::LocalCXXRuntimeOverrides CXXRuntimeOverrides;
Modified: llvm/trunk/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp?rev=251933&r1=251932&r2=251933&view=diff
==============================================================================
--- llvm/trunk/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp (original)
+++ llvm/trunk/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp Tue Nov 3 10:10:18 2015
@@ -19,11 +19,11 @@ namespace {
class DummyCallbackManager : public orc::JITCompileCallbackManagerBase {
public:
DummyCallbackManager()
- : JITCompileCallbackManagerBase(0, 0), NextStubAddress(0),
+ : JITCompileCallbackManagerBase(0), NextStubAddress(0),
UniversalCompile([]() { return 0; }) {
}
- CompileCallbackInfo getCompileCallback(LLVMContext &Context) override {
+ CompileCallbackInfo getCompileCallback() override {
return CompileCallbackInfo(++NextStubAddress, UniversalCompile);
}
public:
Modified: llvm/trunk/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp?rev=251933&r1=251932&r2=251933&view=diff
==============================================================================
--- llvm/trunk/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp (original)
+++ llvm/trunk/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp Tue Nov 3 10:10:18 2015
@@ -82,7 +82,7 @@ TEST_F(OrcCAPIExecutionTest, TestEagerIR
return;
LLVMOrcJITStackRef JIT =
- LLVMOrcCreateInstance(wrap(TM.get()), LLVMGetGlobalContext());
+ LLVMOrcCreateInstance(wrap(TM.get()));
std::unique_ptr<Module> M = createTestModule(TM->getTargetTriple());
@@ -106,7 +106,7 @@ TEST_F(OrcCAPIExecutionTest, TestLazyIRC
return;
LLVMOrcJITStackRef JIT =
- LLVMOrcCreateInstance(wrap(TM.get()), LLVMGetGlobalContext());
+ LLVMOrcCreateInstance(wrap(TM.get()));
std::unique_ptr<Module> M = createTestModule(TM->getTargetTriple());
@@ -130,7 +130,7 @@ TEST_F(OrcCAPIExecutionTest, TestDirectC
return;
LLVMOrcJITStackRef JIT =
- LLVMOrcCreateInstance(wrap(TM.get()), LLVMGetGlobalContext());
+ LLVMOrcCreateInstance(wrap(TM.get()));
LLVMOrcGetMangledSymbol(JIT, &testFuncName, "testFunc");
More information about the llvm-commits
mailing list