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   OrcLazyJIT(std::unique_ptr<TargetMachine> TM, LLVMContext &Context)
  40     : Error(false), TM(std::move(TM)),
  41       Mang(this->TM->getDataLayout()),
  42       ObjectLayer(),
  43       CompileLayer(ObjectLayer, orc::SimpleCompiler(*this->TM)),
  44       LazyEmitLayer(CompileLayer),
  45       CCMgr(createCallbackMgr(Triple(this->TM->getTargetTriple()), Context)),
  46       CODLayer(LazyEmitLayer, *CCMgr) { }
  47
  48   bool Ok() const { return !Error; }
  49
  50   ModuleHandleT addModule(std::unique_ptr<Module> M) {
  51     // Attach a data-layout if one isn't already present.
  52     if (M->getDataLayout().isDefault())
  53       M->setDataLayout(*TM->getDataLayout());
  54
  55     std::vector<std::unique_ptr<Module>> S;
  56     S.push_back(std::move(M));
  57     return CODLayer.addModuleSet(std::move(S));
  58   }
  59
  60   orc::JITSymbol findSymbol(const std::string &Name) {
  61     return CODLayer.findSymbol(mangle(Name), true);
  62   }
  63
  64   orc::JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name) {
  65     return CODLayer.findSymbolIn(H, mangle(Name), true);
  66   }
  67
  68 private:
  69
  70   std::unique_ptr<CompileCallbackMgr>
  71   createCallbackMgr(Triple T, LLVMContext &Context);
  72
  73   std::string mangle(const std::string &Name) {
  74     std::string MangledName;
  75     {
  76       raw_string_ostream MangledNameStream(MangledName);
  77       Mang.getNameWithPrefix(MangledNameStream, Name);
  78     }
  79     return MangledName;
  80   }
  81
  82   bool Error;
  83   std::unique_ptr<TargetMachine> TM;
  84   Mangler Mang;
  85   SectionMemoryManager CCMgrMemMgr;
  86
  87   ObjLayerT ObjectLayer;
  88   CompileLayerT CompileLayer;
  89   LazyEmitLayerT LazyEmitLayer;
  90   std::unique_ptr<CompileCallbackMgr> CCMgr;
  91   CODLayerT CODLayer;
  92 };
  93
  94 int runOrcLazyJIT(std::unique_ptr<Module> M, int ArgC, char* ArgV[]);
  95
  96 } // end namespace llvm
  97
  98 #endif