1 //===- CompileUtils.h - Utilities for compiling IR in the JIT ---*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Contains utilities for compiling IR to object files. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_EXECUTIONENGINE_ORC_COMPILEUTILS_H 14 #define LLVM_EXECUTIONENGINE_ORC_COMPILEUTILS_H 15 16 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h" 17 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h" 18 #include "llvm/ExecutionEngine/Orc/Layer.h" 19 #include <memory> 20 21 namespace llvm { 22 23 class MCContext; 24 class MemoryBuffer; 25 class Module; 26 class ObjectCache; 27 class TargetMachine; 28 29 namespace orc { 30 31 IRSymbolMapper::ManglingOptions 32 irManglingOptionsFromTargetOptions(const TargetOptions &Opts); 33 34 /// Simple compile functor: Takes a single IR module and returns an ObjectFile. 35 /// This compiler supports a single compilation thread and LLVMContext only. 36 /// For multithreaded compilation, use ConcurrentIRCompiler below. 37 class SimpleCompiler : public IRCompileLayer::IRCompiler { 38 public: 39 using CompileResult = std::unique_ptr<MemoryBuffer>; 40 41 /// Construct a simple compile functor with the given target. 42 SimpleCompiler(TargetMachine &TM, ObjectCache *ObjCache = nullptr) 43 : IRCompiler(irManglingOptionsFromTargetOptions(TM.Options)), TM(TM), 44 ObjCache(ObjCache) {} 45 46 /// Set an ObjectCache to query before compiling. setObjectCache(ObjectCache * NewCache)47 void setObjectCache(ObjectCache *NewCache) { ObjCache = NewCache; } 48 49 /// Compile a Module to an ObjectFile. 50 Expected<CompileResult> operator()(Module &M) override; 51 52 private: 53 IRSymbolMapper::ManglingOptions 54 manglingOptionsForTargetMachine(const TargetMachine &TM); 55 56 CompileResult tryToLoadFromObjectCache(const Module &M); 57 void notifyObjectCompiled(const Module &M, const MemoryBuffer &ObjBuffer); 58 59 TargetMachine &TM; 60 ObjectCache *ObjCache = nullptr; 61 }; 62 63 /// A SimpleCompiler that owns its TargetMachine. 64 /// 65 /// This convenient for clients who don't want to own their TargetMachines, 66 /// e.g. LLJIT. 67 class TMOwningSimpleCompiler : public SimpleCompiler { 68 public: 69 TMOwningSimpleCompiler(std::unique_ptr<TargetMachine> TM, 70 ObjectCache *ObjCache = nullptr) 71 : SimpleCompiler(*TM, ObjCache), TM(std::move(TM)) {} 72 73 private: 74 // FIXME: shared because std::functions (and consequently 75 // IRCompileLayer::CompileFunction) are not moveable. 76 std::shared_ptr<llvm::TargetMachine> TM; 77 }; 78 79 /// A thread-safe version of SimpleCompiler. 80 /// 81 /// This class creates a new TargetMachine and SimpleCompiler instance for each 82 /// compile. 83 class ConcurrentIRCompiler : public IRCompileLayer::IRCompiler { 84 public: 85 ConcurrentIRCompiler(JITTargetMachineBuilder JTMB, 86 ObjectCache *ObjCache = nullptr); 87 setObjectCache(ObjectCache * ObjCache)88 void setObjectCache(ObjectCache *ObjCache) { this->ObjCache = ObjCache; } 89 90 Expected<std::unique_ptr<MemoryBuffer>> operator()(Module &M) override; 91 92 private: 93 JITTargetMachineBuilder JTMB; 94 ObjectCache *ObjCache = nullptr; 95 }; 96 97 } // end namespace orc 98 99 } // end namespace llvm 100 101 #endif // LLVM_EXECUTIONENGINE_ORC_COMPILEUTILS_H 102