LCOV - code coverage report
Current view: top level - include/llvm/ExecutionEngine/Orc - LLJIT.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 15 16 93.8 %
Date: 2018-10-20 13:21:21 Functions: 5 6 83.3 %
Legend: Lines: hit not hit

          Line data    Source code
       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/JITTargetMachineBuilder.h"
      23             : #include "llvm/ExecutionEngine/Orc/ObjectTransformLayer.h"
      24             : #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
      25             : #include "llvm/ExecutionEngine/Orc/ThreadSafeModule.h"
      26             : #include "llvm/Support/ThreadPool.h"
      27             : 
      28             : namespace llvm {
      29             : namespace orc {
      30             : 
      31             : /// A pre-fabricated ORC JIT stack that can serve as an alternative to MCJIT.
      32             : class LLJIT {
      33             : public:
      34             : 
      35             :   /// Destruct this instance. If a multi-threaded instance, waits for all
      36             :   /// compile threads to complete.
      37             :   ~LLJIT();
      38             : 
      39             :   /// Create an LLJIT instance.
      40             :   /// If NumCompileThreads is not equal to zero, creates a multi-threaded
      41             :   /// LLJIT with the given number of compile threads.
      42             :   static Expected<std::unique_ptr<LLJIT>>
      43             :   Create(JITTargetMachineBuilder JTMB, DataLayout DL,
      44             :          unsigned NumCompileThreads = 0);
      45             : 
      46             :   /// Returns the ExecutionSession for this instance.
      47             :   ExecutionSession &getExecutionSession() { return *ES; }
      48             : 
      49             :   /// Returns a reference to the JITDylib representing the JIT'd main program.
      50           0 :   JITDylib &getMainJITDylib() { return Main; }
      51             : 
      52             :   /// Convenience method for defining an absolute symbol.
      53             :   Error defineAbsolute(StringRef Name, JITEvaluatedSymbol Address);
      54             : 
      55             :   /// Convenience method for defining an
      56             : 
      57             :   /// Adds an IR module to the given JITDylib.
      58             :   Error addIRModule(JITDylib &JD, ThreadSafeModule TSM);
      59             : 
      60             :   /// Adds an IR module to the Main JITDylib.
      61             :   Error addIRModule(ThreadSafeModule TSM) {
      62             :     return addIRModule(Main, std::move(TSM));
      63             :   }
      64             : 
      65             :   /// Adds an object file to the given JITDylib.
      66             :   Error addObjectFile(JITDylib &JD, std::unique_ptr<MemoryBuffer> Obj);
      67             : 
      68             :   /// Adds an object file to the given JITDylib.
      69           4 :   Error addObjectFile(std::unique_ptr<MemoryBuffer> Obj) {
      70           4 :     return addObjectFile(Main, std::move(Obj));
      71             :   }
      72             : 
      73             :   /// Look up a symbol in JITDylib JD by the symbol's linker-mangled name (to
      74             :   /// look up symbols based on their IR name use the lookup function instead).
      75             :   Expected<JITEvaluatedSymbol> lookupLinkerMangled(JITDylib &JD,
      76             :                                                    StringRef Name);
      77             : 
      78             :   /// Look up a symbol in the main JITDylib by the symbol's linker-mangled name
      79             :   /// (to look up symbols based on their IR name use the lookup function
      80             :   /// instead).
      81             :   Expected<JITEvaluatedSymbol> lookupLinkerMangled(StringRef Name) {
      82             :     return lookupLinkerMangled(Main, Name);
      83             :   }
      84             : 
      85             :   /// Look up a symbol in JITDylib JD based on its IR symbol name.
      86          13 :   Expected<JITEvaluatedSymbol> lookup(JITDylib &JD, StringRef UnmangledName) {
      87          13 :     return lookupLinkerMangled(JD, mangle(UnmangledName));
      88             :   }
      89             : 
      90             :   /// Look up a symbol in the main JITDylib based on its IR symbol name.
      91             :   Expected<JITEvaluatedSymbol> lookup(StringRef UnmangledName) {
      92          13 :     return lookup(Main, UnmangledName);
      93             :   }
      94             : 
      95             :   /// Runs all not-yet-run static constructors.
      96          12 :   Error runConstructors() { return CtorRunner.run(); }
      97             : 
      98             :   /// Runs all not-yet-run static destructors.
      99          12 :   Error runDestructors() { return DtorRunner.run(); }
     100             : 
     101             :   /// Returns a reference to the ObjLinkingLayer
     102             :   RTDyldObjectLinkingLayer &getObjLinkingLayer() { return ObjLinkingLayer; }
     103             : 
     104             : protected:
     105             : 
     106             :   /// Create an LLJIT instance with a single compile thread.
     107             :   LLJIT(std::unique_ptr<ExecutionSession> ES, std::unique_ptr<TargetMachine> TM,
     108             :         DataLayout DL);
     109             : 
     110             :   /// Create an LLJIT instance with multiple compile threads.
     111             :   LLJIT(std::unique_ptr<ExecutionSession> ES, JITTargetMachineBuilder JTMB,
     112             :         DataLayout DL, unsigned NumCompileThreads);
     113             : 
     114             :   std::string mangle(StringRef UnmangledName);
     115             : 
     116             :   Error applyDataLayout(Module &M);
     117             : 
     118             :   void recordCtorDtors(Module &M);
     119             : 
     120             :   std::unique_ptr<ExecutionSession> ES;
     121             :   JITDylib &Main;
     122             : 
     123             :   DataLayout DL;
     124             :   std::unique_ptr<ThreadPool> CompileThreads;
     125             : 
     126             :   RTDyldObjectLinkingLayer ObjLinkingLayer;
     127             :   IRCompileLayer CompileLayer;
     128             : 
     129             :   CtorDtorRunner CtorRunner, DtorRunner;
     130             : };
     131             : 
     132             : /// An extended version of LLJIT that supports lazy function-at-a-time
     133             : /// compilation of LLVM IR.
     134             : class LLLazyJIT : public LLJIT {
     135             : public:
     136             : 
     137             :   /// Create an LLLazyJIT instance.
     138             :   /// If NumCompileThreads is not equal to zero, creates a multi-threaded
     139             :   /// LLLazyJIT with the given number of compile threads.
     140             :   static Expected<std::unique_ptr<LLLazyJIT>>
     141             :   Create(JITTargetMachineBuilder JTMB, DataLayout DL,
     142             :          unsigned NumCompileThreads = 0);
     143             : 
     144             :   /// Set an IR transform (e.g. pass manager pipeline) to run on each function
     145             :   /// when it is compiled.
     146          13 :   void setLazyCompileTransform(IRTransformLayer::TransformFunction Transform) {
     147          13 :     TransformLayer.setTransform(std::move(Transform));
     148          13 :   }
     149             : 
     150             :   /// Sets the partition function.
     151             :   void
     152           1 :   setPartitionFunction(CompileOnDemandLayer::PartitionFunction Partition) {
     153           2 :     CODLayer.setPartitionFunction(std::move(Partition));
     154           1 :   }
     155             : 
     156             :   /// Add a module to be lazily compiled to JITDylib JD.
     157             :   Error addLazyIRModule(JITDylib &JD, ThreadSafeModule M);
     158             : 
     159             :   /// Add a module to be lazily compiled to the main JITDylib.
     160          14 :   Error addLazyIRModule(ThreadSafeModule M) {
     161          14 :     return addLazyIRModule(Main, std::move(M));
     162             :   }
     163             : 
     164             : private:
     165             : 
     166             :   // Create a single-threaded LLLazyJIT instance.
     167             :   LLLazyJIT(std::unique_ptr<ExecutionSession> ES,
     168             :             std::unique_ptr<TargetMachine> TM, DataLayout DL,
     169             :             std::unique_ptr<LazyCallThroughManager> LCTMgr,
     170             :             std::function<std::unique_ptr<IndirectStubsManager>()> ISMBuilder);
     171             : 
     172             :   // Create a multi-threaded LLLazyJIT instance.
     173             :   LLLazyJIT(std::unique_ptr<ExecutionSession> ES, JITTargetMachineBuilder JTMB,
     174             :             DataLayout DL, unsigned NumCompileThreads,
     175             :             std::unique_ptr<LazyCallThroughManager> LCTMgr,
     176             :             std::function<std::unique_ptr<IndirectStubsManager>()> ISMBuilder);
     177             : 
     178             :   std::unique_ptr<LazyCallThroughManager> LCTMgr;
     179             :   std::function<std::unique_ptr<IndirectStubsManager>()> ISMBuilder;
     180             : 
     181             :   IRTransformLayer TransformLayer;
     182             :   CompileOnDemandLayer CODLayer;
     183             : };
     184             : 
     185             : } // End namespace orc
     186             : } // End namespace llvm
     187             : 
     188             : #endif // LLVM_EXECUTIONENGINE_ORC_LLJIT_H

Generated by: LCOV version 1.13