Home | History | Annotate | Download | only in Orc 
      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/ExecutionEngine/Orc/ExecutionUtils.h"
     20 #include "llvm/IR/LegacyPassManager.h"
     21 #include "llvm/Object/Binary.h"
     22 #include "llvm/Object/ObjectFile.h"
     23 #include "llvm/Support/Error.h"
     24 #include "llvm/Support/ErrorHandling.h"
     25 #include "llvm/Support/MemoryBuffer.h"
     26 #include "llvm/Support/SmallVectorMemoryBuffer.h"
     27 #include "llvm/Support/raw_ostream.h"
     28 #include "llvm/Target/TargetMachine.h"
     29 #include <algorithm>
     30 #include <memory>
     31 
     32 namespace llvm {
     33 
     34 class MCContext;
     35 class Module;
     36 
     37 namespace orc {
     38 
     39 /// Simple compile functor: Takes a single IR module and returns an ObjectFile.
     40 /// This compiler supports a single compilation thread and LLVMContext only.
     41 /// For multithreaded compilation, use MultiThreadedSimpleCompiler below.
     42 class SimpleCompiler {
     43 public:
     44   using CompileResult = std::unique_ptr<MemoryBuffer>;
     45 
     46   /// Construct a simple compile functor with the given target.
     47   SimpleCompiler(TargetMachine &TM, ObjectCache *ObjCache = nullptr)
     48     : TM(TM), ObjCache(ObjCache) {}
     49 
     50   /// Set an ObjectCache to query before compiling.
     51   void setObjectCache(ObjectCache *NewCache) { ObjCache = NewCache; }
     52 
     53   /// Compile a Module to an ObjectFile.
     54   CompileResult operator()(Module &M) {
     55     CompileResult CachedObject = tryToLoadFromObjectCache(M);
     56     if (CachedObject)
     57       return CachedObject;
     58 
     59     SmallVector<char, 0> ObjBufferSV;
     60 
     61     {
     62       raw_svector_ostream ObjStream(ObjBufferSV);
     63 
     64       legacy::PassManager PM;
     65       MCContext *Ctx;
     66       if (TM.addPassesToEmitMC(PM, Ctx, ObjStream))
     67         llvm_unreachable("Target does not support MC emission.");
     68       PM.run(M);
     69     }
     70 
     71     auto ObjBuffer =
     72         llvm::make_unique<SmallVectorMemoryBuffer>(std::move(ObjBufferSV));
     73     auto Obj =
     74         object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef());
     75 
     76     if (Obj) {
     77       notifyObjectCompiled(M, *ObjBuffer);
     78       return std::move(ObjBuffer);
     79     }
     80 
     81     // TODO: Actually report errors helpfully.
     82     consumeError(Obj.takeError());
     83     return nullptr;
     84   }
     85 
     86 private:
     87 
     88   CompileResult tryToLoadFromObjectCache(const Module &M) {
     89     if (!ObjCache)
     90       return CompileResult();
     91 
     92     return ObjCache->getObject(&M);
     93   }
     94 
     95   void notifyObjectCompiled(const Module &M, const MemoryBuffer &ObjBuffer) {
     96     if (ObjCache)
     97       ObjCache->notifyObjectCompiled(&M, ObjBuffer.getMemBufferRef());
     98   }
     99 
    100   TargetMachine &TM;
    101   ObjectCache *ObjCache = nullptr;
    102 };
    103 
    104 /// A thread-safe version of SimpleCompiler.
    105 ///
    106 /// This class creates a new TargetMachine and SimpleCompiler instance for each
    107 /// compile.
    108 class MultiThreadedSimpleCompiler {
    109 public:
    110   MultiThreadedSimpleCompiler(JITTargetMachineBuilder JTMB,
    111                               ObjectCache *ObjCache = nullptr)
    112       : JTMB(std::move(JTMB)), ObjCache(ObjCache) {}
    113 
    114   void setObjectCache(ObjectCache *ObjCache) { this->ObjCache = ObjCache; }
    115 
    116   std::unique_ptr<MemoryBuffer> operator()(Module &M) {
    117     auto TM = cantFail(JTMB.createTargetMachine());
    118     SimpleCompiler C(*TM, ObjCache);
    119     return C(M);
    120   }
    121 
    122 private:
    123   JITTargetMachineBuilder JTMB;
    124   ObjectCache *ObjCache = nullptr;
    125 };
    126 
    127 } // end namespace orc
    128 
    129 } // end namespace llvm
    130 
    131 #endif // LLVM_EXECUTIONENGINE_ORC_COMPILEUTILS_H
    132