contrib/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h

   1 //===----- LLJIT.h -- An ORC-based JIT for compiling LLVM IR ----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for 3Bdetails.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // An ORC-based JIT for compiling LLVM IR.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_EXECUTIONENGINE_ORC_LLJIT_H
  15 #define LLVM_EXECUTIONENGINE_ORC_LLJIT_H
  16
  17 #include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"
  18 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
  19 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
  20 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
  21 #include "llvm/ExecutionEngine/Orc/IRTransformLayer.h"
  22 #include "llvm/ExecutionEngine/Orc/ObjectTransformLayer.h"
  23 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
  24 #include "llvm/Target/TargetMachine.h"
  25
  26 namespace llvm {
  27 namespace orc {
  28
  29 /// A pre-fabricated ORC JIT stack that can serve as an alternative to MCJIT.
  30 class LLJIT {
  31 public:
  32   /// Create an LLJIT instance.
  33   static Expected<std::unique_ptr<LLJIT>>
  34   Create(std::unique_ptr<ExecutionSession> ES,
  35          std::unique_ptr<TargetMachine> TM, DataLayout DL);
  36
  37   /// Returns a reference to the ExecutionSession for this JIT instance.
  38   ExecutionSession &getExecutionSession() { return *ES; }
  39
  40   /// Returns a reference to the VSO representing the JIT'd main program.
  41   VSO &getMainVSO() { return Main; }
  42
  43   /// Convenience method for defining an absolute symbol.
  44   Error defineAbsolute(StringRef Name, JITEvaluatedSymbol Address);
  45
  46   /// Adds an IR module to the given VSO.
  47   Error addIRModule(VSO &V, std::unique_ptr<Module> M);
  48
  49   /// Adds an IR module to the Main VSO.
  50   Error addIRModule(std::unique_ptr<Module> M) {
  51     return addIRModule(Main, std::move(M));
  52   }
  53
  54   /// Look up a symbol in VSO V by the symbol's linker-mangled name (to look up
  55   /// symbols based on their IR name use the lookup function instead).
  56   Expected<JITEvaluatedSymbol> lookupLinkerMangled(VSO &V, StringRef Name);
  57
  58   /// Look up a symbol in the main VSO by the symbol's linker-mangled name (to
  59   /// look up symbols based on their IR name use the lookup function instead).
  60   Expected<JITEvaluatedSymbol> lookupLinkerMangled(StringRef Name) {
  61     return lookupLinkerMangled(Main, Name);
  62   }
  63
  64   /// Look up a symbol in VSO V based on its IR symbol name.
  65   Expected<JITEvaluatedSymbol> lookup(VSO &V, StringRef UnmangledName) {
  66     return lookupLinkerMangled(V, mangle(UnmangledName));
  67   }
  68
  69   /// Look up a symbol in the main VSO based on its IR symbol name.
  70   Expected<JITEvaluatedSymbol> lookup(StringRef UnmangledName) {
  71     return lookup(Main, UnmangledName);
  72   }
  73
  74   /// Runs all not-yet-run static constructors.
  75   Error runConstructors() { return CtorRunner.run(); }
  76
  77   /// Runs all not-yet-run static destructors.
  78   Error runDestructors() { return DtorRunner.run(); }
  79
  80 protected:
  81   LLJIT(std::unique_ptr<ExecutionSession> ES, std::unique_ptr<TargetMachine> TM,
  82         DataLayout DL);
  83
  84   std::shared_ptr<RuntimeDyld::MemoryManager> getMemoryManager(VModuleKey K);
  85
  86   std::string mangle(StringRef UnmangledName);
  87
  88   Error applyDataLayout(Module &M);
  89
  90   void recordCtorDtors(Module &M);
  91
  92   std::unique_ptr<ExecutionSession> ES;
  93   VSO &Main;
  94
  95   std::unique_ptr<TargetMachine> TM;
  96   DataLayout DL;
  97
  98   RTDyldObjectLinkingLayer2 ObjLinkingLayer;
  99   IRCompileLayer2 CompileLayer;
 100
 101   CtorDtorRunner2 CtorRunner, DtorRunner;
 102 };
 103
 104 /// An extended version of LLJIT that supports lazy function-at-a-time
 105 /// compilation of LLVM IR.
 106 class LLLazyJIT : public LLJIT {
 107 public:
 108   /// Create an LLLazyJIT instance.
 109   static Expected<std::unique_ptr<LLLazyJIT>>
 110   Create(std::unique_ptr<ExecutionSession> ES,
 111          std::unique_ptr<TargetMachine> TM, DataLayout DL, LLVMContext &Ctx);
 112
 113   /// Set an IR transform (e.g. pass manager pipeline) to run on each function
 114   /// when it is compiled.
 115   void setLazyCompileTransform(IRTransformLayer2::TransformFunction Transform) {
 116     TransformLayer.setTransform(std::move(Transform));
 117   }
 118
 119   /// Add a module to be lazily compiled to VSO V.
 120   Error addLazyIRModule(VSO &V, std::unique_ptr<Module> M);
 121
 122   /// Add a module to be lazily compiled to the main VSO.
 123   Error addLazyIRModule(std::unique_ptr<Module> M) {
 124     return addLazyIRModule(Main, std::move(M));
 125   }
 126
 127 private:
 128   LLLazyJIT(std::unique_ptr<ExecutionSession> ES,
 129             std::unique_ptr<TargetMachine> TM, DataLayout DL, LLVMContext &Ctx,
 130             std::unique_ptr<JITCompileCallbackManager> CCMgr,
 131             std::function<std::unique_ptr<IndirectStubsManager>()> ISMBuilder);
 132
 133   std::unique_ptr<JITCompileCallbackManager> CCMgr;
 134   std::function<std::unique_ptr<IndirectStubsManager>()> ISMBuilder;
 135
 136   IRTransformLayer2 TransformLayer;
 137   CompileOnDemandLayer2 CODLayer;
 138 };
 139
 140 } // End namespace orc
 141 } // End namespace llvm
 142
 143 #endif // LLVM_EXECUTIONENGINE_ORC_LLJIT_H