LCOV - code coverage report
Current view: top level - include/llvm/ExecutionEngine/Orc - CompileUtils.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 23 26 88.5 %
Date: 2018-05-20 00:06:23 Functions: 10 11 90.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- CompileUtils.h - Utilities for compiling IR in the JIT ---*- 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             : // Contains utilities for compiling IR to object files.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_EXECUTIONENGINE_ORC_COMPILEUTILS_H
      15             : #define LLVM_EXECUTIONENGINE_ORC_COMPILEUTILS_H
      16             : 
      17             : #include "llvm/ADT/SmallVector.h"
      18             : #include "llvm/ExecutionEngine/ObjectCache.h"
      19             : #include "llvm/IR/LegacyPassManager.h"
      20             : #include "llvm/Object/Binary.h"
      21             : #include "llvm/Object/ObjectFile.h"
      22             : #include "llvm/Support/Error.h"
      23             : #include "llvm/Support/ErrorHandling.h"
      24             : #include "llvm/Support/MemoryBuffer.h"
      25             : #include "llvm/Support/SmallVectorMemoryBuffer.h"
      26             : #include "llvm/Support/raw_ostream.h"
      27             : #include "llvm/Target/TargetMachine.h"
      28             : #include <algorithm>
      29             : #include <memory>
      30             : 
      31             : namespace llvm {
      32             : 
      33             : class MCContext;
      34             : class Module;
      35             : 
      36             : namespace orc {
      37             : 
      38             : /// Simple compile functor: Takes a single IR module and returns an
      39             : ///        ObjectFile.
      40             : class SimpleCompiler {
      41             : private:
      42         375 :   class SmallVectorMemoryBuffer : public MemoryBuffer {
      43             :   public:
      44         125 :     SmallVectorMemoryBuffer(SmallVector<char, 0> Buffer)
      45         125 :         : Buffer(std::move(Buffer)) {
      46         250 :       init(this->Buffer.data(), this->Buffer.data() + this->Buffer.size(),
      47             :            false);
      48         125 :     }
      49             : 
      50           0 :     BufferKind getBufferKind() const override { return MemoryBuffer_Malloc; }
      51             : 
      52             :   private:
      53             :     SmallVector<char, 0> Buffer;
      54             :   };
      55             : 
      56             : public:
      57             :   using CompileResult = std::unique_ptr<MemoryBuffer>;
      58             : 
      59             :   /// Construct a simple compile functor with the given target.
      60             :   SimpleCompiler(TargetMachine &TM, ObjectCache *ObjCache = nullptr)
      61          12 :     : TM(TM), ObjCache(ObjCache) {}
      62             : 
      63             :   /// Set an ObjectCache to query before compiling.
      64           1 :   void setObjectCache(ObjectCache *NewCache) { ObjCache = NewCache; }
      65             : 
      66             :   /// Compile a Module to an ObjectFile.
      67         125 :   CompileResult operator()(Module &M) {
      68         125 :     CompileResult CachedObject = tryToLoadFromObjectCache(M);
      69         125 :     if (CachedObject)
      70             :       return CachedObject;
      71             : 
      72             :     SmallVector<char, 0> ObjBufferSV;
      73             : 
      74             :     {
      75             :       raw_svector_ostream ObjStream(ObjBufferSV);
      76             : 
      77         250 :       legacy::PassManager PM;
      78             :       MCContext *Ctx;
      79         125 :       if (TM.addPassesToEmitMC(PM, Ctx, ObjStream))
      80           0 :         llvm_unreachable("Target does not support MC emission.");
      81         125 :       PM.run(M);
      82             :     }
      83             : 
      84             :     auto ObjBuffer =
      85         125 :         llvm::make_unique<SmallVectorMemoryBuffer>(std::move(ObjBufferSV));
      86             :     auto Obj =
      87         250 :         object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef());
      88             : 
      89         125 :     if (Obj) {
      90         125 :       notifyObjectCompiled(M, *ObjBuffer);
      91             :       return std::move(ObjBuffer);
      92             :     }
      93             : 
      94             :     // TODO: Actually report errors helpfully.
      95           0 :     consumeError(Obj.takeError());
      96             :     return nullptr;
      97             :   }
      98             : 
      99             : private:
     100             : 
     101             :   CompileResult tryToLoadFromObjectCache(const Module &M) {
     102         125 :     if (!ObjCache)
     103             :       return CompileResult();
     104             : 
     105           3 :     return ObjCache->getObject(&M);
     106             :   }
     107             : 
     108         125 :   void notifyObjectCompiled(const Module &M, const MemoryBuffer &ObjBuffer) {
     109         125 :     if (ObjCache)
     110           3 :       ObjCache->notifyObjectCompiled(&M, ObjBuffer.getMemBufferRef());
     111         125 :   }
     112             : 
     113             :   TargetMachine &TM;
     114             :   ObjectCache *ObjCache = nullptr;
     115             : };
     116             : 
     117             : } // end namespace orc
     118             : 
     119             : } // end namespace llvm
     120             : 
     121             : #endif // LLVM_EXECUTIONENGINE_ORC_COMPILEUTILS_H

Generated by: LCOV version 1.13