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/ExecutionEngine/RTDyldMemoryManager.h"
  25 #include "llvm/IR/LLVMContext.h"
  26
  27 namespace llvm {
  28
  29 class OrcLazyJIT {
  30 public:
  31
  32   typedef orc::JITCompileCallbackManagerBase CompileCallbackMgr;
  33   typedef orc::ObjectLinkingLayer<> ObjLayerT;
  34   typedef orc::IRCompileLayer<ObjLayerT> CompileLayerT;
  35   typedef orc::LazyEmittingLayer<CompileLayerT> LazyEmitLayerT;
  36   typedef orc::CompileOnDemandLayer<LazyEmitLayerT,
  37                                     CompileCallbackMgr> CODLayerT;
  38   typedef CODLayerT::ModuleSetHandleT ModuleHandleT;
  39
  40   typedef std::function<
  41             std::unique_ptr<CompileCallbackMgr>(CompileLayerT&,
  42                                                 RuntimeDyld::MemoryManager&,
  43                                                 LLVMContext&)>
  44     CallbackManagerBuilder;
  45
  46   static CallbackManagerBuilder createCallbackManagerBuilder(Triple T);
  47
  48   OrcLazyJIT(std::unique_ptr<TargetMachine> TM, LLVMContext &Context,
  49              CallbackManagerBuilder &BuildCallbackMgr)
  50     : TM(std::move(TM)),
  51       Mang(this->TM->getDataLayout()),
  52       ObjectLayer(),
  53       CompileLayer(ObjectLayer, orc::SimpleCompiler(*this->TM)),
  54       LazyEmitLayer(CompileLayer),
  55       CCMgr(BuildCallbackMgr(CompileLayer, CCMgrMemMgr, Context)),
  56       CODLayer(LazyEmitLayer, *CCMgr) { }
  57
  58   ModuleHandleT addModule(std::unique_ptr<Module> M) {
  59     // Attach a data-layout if one isn't already present.
  60     if (M->getDataLayout().isDefault())
  61       M->setDataLayout(*TM->getDataLayout());
  62
  63     std::vector<std::unique_ptr<Module>> S;
  64     S.push_back(std::move(M));
  65     auto FallbackLookup =
  66       [](const std::string &Name) {
  67         if (auto Addr = RTDyldMemoryManager::getSymbolAddressInProcess(Name))
  68           return RuntimeDyld::SymbolInfo(Addr, JITSymbolFlags::Exported);
  69         return RuntimeDyld::SymbolInfo(nullptr);
  70       };
  71     return CODLayer.addModuleSet(std::move(S), std::move(FallbackLookup));
  72   }
  73
  74   orc::JITSymbol findSymbol(const std::string &Name) {
  75     return CODLayer.findSymbol(mangle(Name), true);
  76   }
  77
  78   orc::JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name) {
  79     return CODLayer.findSymbolIn(H, mangle(Name), true);
  80   }
  81
  82 private:
  83
  84   std::string mangle(const std::string &Name) {
  85     std::string MangledName;
  86     {
  87       raw_string_ostream MangledNameStream(MangledName);
  88       Mang.getNameWithPrefix(MangledNameStream, Name);
  89     }
  90     return MangledName;
  91   }
  92
  93   std::unique_ptr<TargetMachine> TM;
  94   Mangler Mang;
  95   SectionMemoryManager CCMgrMemMgr;
  96
  97   ObjLayerT ObjectLayer;
  98   CompileLayerT CompileLayer;
  99   LazyEmitLayerT LazyEmitLayer;
 100   std::unique_ptr<CompileCallbackMgr> CCMgr;
 101   CODLayerT CODLayer;
 102 };
 103
 104 int runOrcLazyJIT(std::unique_ptr<Module> M, int ArgC, char* ArgV[]);
 105
 106 } // end namespace llvm
 107
 108 #endif