1//===------ OrcTestCommon.h - Utilities for Orc Unit Tests ------*- 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// Common utilities for the Orc unit tests. 11// 12//===----------------------------------------------------------------------===// 13 14 15#ifndef LLVM_UNITTESTS_EXECUTIONENGINE_ORC_ORCTESTCOMMON_H 16#define LLVM_UNITTESTS_EXECUTIONENGINE_ORC_ORCTESTCOMMON_H 17 18#include "llvm/IR/Function.h" 19#include "llvm/IR/IRBuilder.h" 20#include "llvm/IR/LLVMContext.h" 21#include "llvm/IR/Module.h" 22#include "llvm/IR/TypeBuilder.h" 23#include "llvm/Object/ObjectFile.h" 24#include "llvm/ExecutionEngine/ExecutionEngine.h" 25#include "llvm/ExecutionEngine/Orc/JITSymbol.h" 26#include "llvm/Support/TargetSelect.h" 27#include <memory> 28 29namespace llvm { 30 31// Base class for Orc tests that will execute code. 32class OrcExecutionTest { 33public: 34 35 OrcExecutionTest() { 36 if (!NativeTargetInitialized) { 37 InitializeNativeTarget(); 38 InitializeNativeTargetAsmParser(); 39 InitializeNativeTargetAsmPrinter(); 40 NativeTargetInitialized = true; 41 } 42 43 // Try to select a TargetMachine for the host. 44 TM.reset(EngineBuilder().selectTarget()); 45 46 if (TM) { 47 // If we found a TargetMachine, check that it's one that Orc supports. 48 const Triple& TT = TM->getTargetTriple(); 49 50 if ((TT.getArch() != Triple::x86_64 && TT.getArch() != Triple::x86) || 51 TT.isOSWindows()) 52 TM = nullptr; 53 } 54 }; 55 56protected: 57 LLVMContext Context; 58 std::unique_ptr<TargetMachine> TM; 59private: 60 static bool NativeTargetInitialized; 61}; 62 63class ModuleBuilder { 64public: 65 ModuleBuilder(LLVMContext &Context, StringRef Triple, 66 StringRef Name); 67 68 template <typename FuncType> 69 Function* createFunctionDecl(StringRef Name) { 70 return Function::Create( 71 TypeBuilder<FuncType, false>::get(M->getContext()), 72 GlobalValue::ExternalLinkage, Name, M.get()); 73 } 74 75 Module* getModule() { return M.get(); } 76 const Module* getModule() const { return M.get(); } 77 std::unique_ptr<Module> takeModule() { return std::move(M); } 78 79private: 80 std::unique_ptr<Module> M; 81}; 82 83// Dummy struct type. 84struct DummyStruct { 85 int X[256]; 86}; 87 88// TypeBuilder specialization for DummyStruct. 89template <bool XCompile> 90class TypeBuilder<DummyStruct, XCompile> { 91public: 92 static StructType *get(LLVMContext &Context) { 93 return StructType::get( 94 TypeBuilder<types::i<32>[256], XCompile>::get(Context), nullptr); 95 } 96}; 97 98template <typename HandleT, 99 typename AddModuleSetFtor, 100 typename RemoveModuleSetFtor, 101 typename FindSymbolFtor, 102 typename FindSymbolInFtor> 103class MockBaseLayer { 104public: 105 106 typedef HandleT ModuleSetHandleT; 107 108 MockBaseLayer(AddModuleSetFtor &&AddModuleSet, 109 RemoveModuleSetFtor &&RemoveModuleSet, 110 FindSymbolFtor &&FindSymbol, 111 FindSymbolInFtor &&FindSymbolIn) 112 : AddModuleSet(AddModuleSet), RemoveModuleSet(RemoveModuleSet), 113 FindSymbol(FindSymbol), FindSymbolIn(FindSymbolIn) 114 {} 115 116 template <typename ModuleSetT, typename MemoryManagerPtrT, 117 typename SymbolResolverPtrT> 118 ModuleSetHandleT addModuleSet(ModuleSetT Ms, MemoryManagerPtrT MemMgr, 119 SymbolResolverPtrT Resolver) { 120 return AddModuleSet(std::move(Ms), std::move(MemMgr), std::move(Resolver)); 121 } 122 123 void removeModuleSet(ModuleSetHandleT H) { 124 RemoveModuleSet(H); 125 } 126 127 orc::JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) { 128 return FindSymbol(Name, ExportedSymbolsOnly); 129 } 130 131 orc::JITSymbol findSymbolIn(ModuleSetHandleT H, const std::string &Name, 132 bool ExportedSymbolsOnly) { 133 return FindSymbolIn(H, Name, ExportedSymbolsOnly); 134 } 135 136private: 137 AddModuleSetFtor AddModuleSet; 138 RemoveModuleSetFtor RemoveModuleSet; 139 FindSymbolFtor FindSymbol; 140 FindSymbolInFtor FindSymbolIn; 141}; 142 143template <typename ModuleSetHandleT, 144 typename AddModuleSetFtor, 145 typename RemoveModuleSetFtor, 146 typename FindSymbolFtor, 147 typename FindSymbolInFtor> 148MockBaseLayer<ModuleSetHandleT, AddModuleSetFtor, RemoveModuleSetFtor, 149 FindSymbolFtor, FindSymbolInFtor> 150createMockBaseLayer(AddModuleSetFtor &&AddModuleSet, 151 RemoveModuleSetFtor &&RemoveModuleSet, 152 FindSymbolFtor &&FindSymbol, 153 FindSymbolInFtor &&FindSymbolIn) { 154 return MockBaseLayer<ModuleSetHandleT, AddModuleSetFtor, RemoveModuleSetFtor, 155 FindSymbolFtor, FindSymbolInFtor>( 156 std::forward<AddModuleSetFtor>(AddModuleSet), 157 std::forward<RemoveModuleSetFtor>(RemoveModuleSet), 158 std::forward<FindSymbolFtor>(FindSymbol), 159 std::forward<FindSymbolInFtor>(FindSymbolIn)); 160} 161 162template <typename ReturnT> 163class DoNothingAndReturn { 164public: 165 DoNothingAndReturn(ReturnT Val) : Val(Val) {} 166 167 template <typename... Args> 168 ReturnT operator()(Args...) const { return Val; } 169private: 170 ReturnT Val; 171}; 172 173template <> 174class DoNothingAndReturn<void> { 175public: 176 template <typename... Args> 177 void operator()(Args...) const { } 178}; 179 180} // namespace llvm 181 182#endif 183