[llvm] r251933 - [Orc] Directly emit machine code for the x86 resolver block and trampolines.
Rafael Espíndola via llvm-commits
llvm-commits at lists.llvm.org
Tue Nov 3 08:43:57 PST 2015
Added back in r251944 and now everything works.
Thanks for fixing the example.
Cheers,
Rafael
On 3 November 2015 at 11:42, Lang Hames <lhames at gmail.com> wrote:
> Thanks very much Rafael!
>
> - Lang.
>
> On Tue, Nov 3, 2015 at 5:41 PM, Rafael Espíndola
> <rafael.espindola at gmail.com> wrote:
>>
>> Will do.
>>
>> On 3 November 2015 at 11:40, Lang Hames <lhames at gmail.com> wrote:
>> > Sorry - I should say I committed r251942 to *fix* it. That fix will
>> > break
>> > the builders too if r251933 doesn't go back in.
>> >
>> > - Lang.
>> >
>> > On Tue, Nov 3, 2015 at 5:38 PM, Lang Hames <lhames at gmail.com> wrote:
>> >>
>> >> I just committed r251942 to reinstate it.
>> >>
>> >> Any chance you could re-apply it - I'm traveling and my internet is
>> >> pretty
>> >> patchy. ><
>> >>
>> >> - Lang.
>> >>
>> >> On Tue, Nov 3, 2015 at 5:28 PM, Rafael Espíndola
>> >> <rafael.espindola at gmail.com> wrote:
>> >>>
>> >>> Hi lang,
>> >>>
>> >>> Sorry I reverted this as it broke the build:
>> >>>
>> >>>
>> >>>
>> >>> /home/espindola/llvm/llvm/examples/Kaleidoscope/Orc/fully_lazy/toy.cpp:1314:3:
>> >>> error: too many template arguments for class template
>> >>> 'JITCompileCallbackManager'
>> >>> JITCompileCallbackManager<LazyEmitLayerT, OrcX86_64>
>> >>> CompileCallbacks;
>> >>>
>> >>> On 3 November 2015 at 11:10, Lang Hames via llvm-commits
>> >>> <llvm-commits at lists.llvm.org> wrote:
>> >>> > 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");
>> >>> >
>> >>> >
>> >>> >
>> >>> > _______________________________________________
>> >>> > llvm-commits mailing list
>> >>> > llvm-commits at lists.llvm.org
>> >>> > http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>> >>
>> >>
>> >
>
>
More information about the llvm-commits
mailing list