tools/lli/OrcLazyJIT.h

   1 //===--- OrcLazyJIT.h - Basic Orc-based JIT for lazy execution --*- 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 details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Simple Orc-based JIT. Uses the compile-on-demand layer to break up and
  11 // lazily compile modules.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_TOOLS_LLI_ORCLAZYJIT_H
  16 #define LLVM_TOOLS_LLI_ORCLAZYJIT_H
  17
  18 #include "llvm/ADT/Triple.h"
  19 #include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"
  20 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
  21 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
  22 #include "llvm/ExecutionEngine/Orc/LazyEmittingLayer.h"
  23 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
  24 #include "llvm/IR/LLVMContext.h"
  25
  26 namespace llvm {
  27
  28 class OrcLazyJIT {
  29 public:
  30
  31   typedef orc::JITCompileCallbackManagerBase CompileCallbackMgr;
  32   typedef orc::ObjectLinkingLayer<> ObjLayerT;
  33   typedef orc::IRCompileLayer<ObjLayerT> CompileLayerT;
  34   typedef orc::LazyEmittingLayer<CompileLayerT> LazyEmitLayerT;
  35   typedef orc::CompileOnDemandLayer<LazyEmitLayerT,
  36                                     CompileCallbackMgr> CODLayerT;
  37   typedef CODLayerT::ModuleSetHandleT ModuleHandleT;
  38
  39   typedef std::function<
  40             std::unique_ptr<CompileCallbackMgr>(CompileLayerT&,
  41                                                 RuntimeDyld::MemoryManager&,
  42                                                 LLVMContext&)>
  43     CallbackManagerBuilder;
  44
  45   static CallbackManagerBuilder createCallbackManagerBuilder(Triple T);
  46
  47   OrcLazyJIT(std::unique_ptr<TargetMachine> TM, LLVMContext &Context,
  48              CallbackManagerBuilder &BuildCallbackMgr)
  49     : TM(std::move(TM)),
  50       Mang(this->TM->getDataLayout()),
  51       ObjectLayer(),
  52       CompileLayer(ObjectLayer, orc::SimpleCompiler(*this->TM)),
  53       LazyEmitLayer(CompileLayer),
  54       CCMgr(BuildCallbackMgr(CompileLayer, CCMgrMemMgr, Context)),
  55       CODLayer(LazyEmitLayer, *CCMgr) { }
  56
  57   ModuleHandleT addModule(std::unique_ptr<Module> M) {
  58     // Attach a data-layout if one isn't already present.
  59     if (M->getDataLayout().isDefault())
  60       M->setDataLayout(*TM->getDataLayout());
  61
  62     std::vector<std::unique_ptr<Module>> S;
  63     S.push_back(std::move(M));
  64     return CODLayer.addModuleSet(std::move(S));
  65   }
  66
  67   orc::JITSymbol findSymbol(const std::string &Name) {
  68     return CODLayer.findSymbol(mangle(Name), true);
  69   }
  70
  71   orc::JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name) {
  72     return CODLayer.findSymbolIn(H, mangle(Name), true);
  73   }
  74
  75 private:
  76
  77   std::string mangle(const std::string &Name) {
  78     std::string MangledName;
  79     {
  80       raw_string_ostream MangledNameStream(MangledName);
  81       Mang.getNameWithPrefix(MangledNameStream, Name);
  82     }
  83     return MangledName;
  84   }
  85
  86   std::unique_ptr<TargetMachine> TM;
  87   Mangler Mang;
  88   SectionMemoryManager CCMgrMemMgr;
  89
  90   ObjLayerT ObjectLayer;
  91   CompileLayerT CompileLayer;
  92   LazyEmitLayerT LazyEmitLayer;
  93   std::unique_ptr<CompileCallbackMgr> CCMgr;
  94   CODLayerT CODLayer;
  95 };
  96
  97 int runOrcLazyJIT(std::unique_ptr<Module> M, int ArgC, char* ArgV[]);
  98
  99 } // end namespace llvm
 100
 101 #endif