[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:42:46 PST 2015


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
> >>
> >>
> >
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20151103/bbf86373/attachment-0001.html>


More information about the llvm-commits mailing list