github.com/igggame/nebulas-go@v2.1.0+incompatible/nbre/jit/OrcLazyJIT.h (about)

     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 "common/common.h"
    19  #include "jit/jit_exception.h"
    20  #include "llvm/ADT/Optional.h"
    21  #include "llvm/ADT/STLExtras.h"
    22  #include "llvm/ADT/Triple.h"
    23  #include "llvm/ADT/Twine.h"
    24  #include "llvm/ExecutionEngine/ExecutionEngine.h"
    25  #include "llvm/ExecutionEngine/JITSymbol.h"
    26  #include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"
    27  #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
    28  #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
    29  #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
    30  #include "llvm/ExecutionEngine/Orc/IRTransformLayer.h"
    31  #include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
    32  #include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
    33  #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
    34  #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
    35  #include "llvm/ExecutionEngine/SectionMemoryManager.h"
    36  #include "llvm/IR/DataLayout.h"
    37  #include "llvm/IR/GlobalValue.h"
    38  #include "llvm/IR/Mangler.h"
    39  #include "llvm/IR/Module.h"
    40  #include "llvm/Support/CodeGen.h"
    41  #include "llvm/Support/CommandLine.h"
    42  #include "llvm/Support/DynamicLibrary.h"
    43  #include "llvm/Support/ErrorHandling.h"
    44  #include "llvm/Support/FileSystem.h"
    45  #include "llvm/Support/raw_ostream.h"
    46  #include "llvm/Target/TargetMachine.h"
    47  #include <algorithm>
    48  #include <cstdint>
    49  #include <cstdio>
    50  #include <cstdlib>
    51  #include <functional>
    52  #include <iostream>
    53  #include <memory>
    54  #include <set>
    55  #include <string>
    56  #include <system_error>
    57  #include <vector>
    58  
    59  namespace neb {
    60  namespace core {
    61  class driver;
    62  }
    63  }
    64  namespace llvm {
    65  
    66  class OrcLazyJIT {
    67  public:
    68    using CompileCallbackMgr = orc::JITCompileCallbackManager;
    69    using ObjLayerT = orc::RTDyldObjectLinkingLayer;
    70    using CompileLayerT = orc::IRCompileLayer<ObjLayerT, orc::SimpleCompiler>;
    71    using TransformFtor =
    72        std::function<std::shared_ptr<Module>(std::shared_ptr<Module>)>;
    73    using IRDumpLayerT = orc::IRTransformLayer<CompileLayerT, TransformFtor>;
    74    using CODLayerT = orc::CompileOnDemandLayer<IRDumpLayerT, CompileCallbackMgr>;
    75    using IndirectStubsManagerBuilder = CODLayerT::IndirectStubsManagerBuilderT;
    76    using ModuleHandleT = CODLayerT::ModuleHandleT;
    77  
    78    OrcLazyJIT(std::unique_ptr<TargetMachine> TM,
    79               std::unique_ptr<CompileCallbackMgr> CCMgr,
    80               IndirectStubsManagerBuilder IndirectStubsMgrBuilder,
    81               bool InlineStubs)
    82        : TM(std::move(TM)), DL(this->TM->createDataLayout()),
    83          CCMgr(std::move(CCMgr)),
    84          ObjectLayer([]() { return std::make_shared<SectionMemoryManager>(); }),
    85          CompileLayer(ObjectLayer, orc::SimpleCompiler(*this->TM)),
    86          IRDumpLayer(CompileLayer, createDebugDumper()),
    87          CODLayer(IRDumpLayer, extractSingleFunction, *this->CCMgr,
    88                   std::move(IndirectStubsMgrBuilder), InlineStubs),
    89          CXXRuntimeOverrides(
    90              [this](const std::string &S) { return mangle(S); }) {}
    91  
    92    ~OrcLazyJIT() {
    93      // Run any destructors registered with __cxa_atexit.
    94      CXXRuntimeOverrides.runDestructors();
    95      // Run any IR destructors.
    96      for (auto &DtorRunner : IRStaticDestructorRunners)
    97        if (auto Err = DtorRunner.runViaLayer(CODLayer)) {
    98          // FIXME: OrcLazyJIT should probably take a "shutdownError" callback to
    99          //        report these errors on.
   100          report_fatal_error(std::move(Err));
   101        }
   102    }
   103  
   104    Error addModule(std::shared_ptr<Module> M);
   105  
   106    JITSymbol findSymbol(const std::string &Name) {
   107      return CODLayer.findSymbol(mangle(Name), true);
   108    }
   109  
   110    JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name) {
   111      return CODLayer.findSymbolIn(H, mangle(Name), true);
   112    }
   113  
   114  private:
   115    std::string mangle(const std::string &Name) {
   116      std::string MangledName;
   117      {
   118        raw_string_ostream MangledNameStream(MangledName);
   119        Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
   120      }
   121      return MangledName;
   122    }
   123  
   124    static std::set<Function *> extractSingleFunction(Function &F) {
   125      std::set<Function *> Partition;
   126      Partition.insert(&F);
   127      return Partition;
   128    }
   129  
   130    static TransformFtor createDebugDumper();
   131  
   132    std::unique_ptr<TargetMachine> TM;
   133    DataLayout DL;
   134    SectionMemoryManager CCMgrMemMgr;
   135  
   136    std::unique_ptr<CompileCallbackMgr> CCMgr;
   137    ObjLayerT ObjectLayer;
   138    CompileLayerT CompileLayer;
   139    IRDumpLayerT IRDumpLayer;
   140    CODLayerT CODLayer;
   141  
   142    orc::LocalCXXRuntimeOverrides CXXRuntimeOverrides;
   143    std::vector<orc::CtorDtorRunner<CODLayerT>> IRStaticDestructorRunners;
   144    llvm::Optional<CODLayerT::ModuleHandleT> ModulesHandle;
   145  };
   146  
   147  
   148  
   149  } // end namespace llvm
   150  
   151  #endif // LLVM_TOOLS_LLI_ORCLAZYJIT_H