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 29 namespace llvm { 30 31 // Base class for Orc tests that will execute code. 32 class OrcExecutionTest { 33 public: 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 56 protected: 57 LLVMContext Context; 58 std::unique_ptr<TargetMachine> TM; 59 private: 60 static bool NativeTargetInitialized; 61 }; 62 63 class ModuleBuilder { 64 public: 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 79 private: 80 std::unique_ptr<Module> M; 81 }; 82 83 // Dummy struct type. 84 struct DummyStruct { 85 int X[256]; 86 }; 87 88 // TypeBuilder specialization for DummyStruct. 89 template <bool XCompile> 90 class TypeBuilder<DummyStruct, XCompile> { 91 public: 92 static StructType *get(LLVMContext &Context) { 93 return StructType::get( 94 TypeBuilder<types::i<32>[256], XCompile>::get(Context), nullptr); 95 } 96 }; 97 98 template <typename HandleT, 99 typename AddModuleSetFtor, 100 typename RemoveModuleSetFtor, 101 typename FindSymbolFtor, 102 typename FindSymbolInFtor> 103 class MockBaseLayer { 104 public: 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 136 private: 137 AddModuleSetFtor AddModuleSet; 138 RemoveModuleSetFtor RemoveModuleSet; 139 FindSymbolFtor FindSymbol; 140 FindSymbolInFtor FindSymbolIn; 141 }; 142 143 template <typename ModuleSetHandleT, 144 typename AddModuleSetFtor, 145 typename RemoveModuleSetFtor, 146 typename FindSymbolFtor, 147 typename FindSymbolInFtor> 148 MockBaseLayer<ModuleSetHandleT, AddModuleSetFtor, RemoveModuleSetFtor, 149 FindSymbolFtor, FindSymbolInFtor> 150 createMockBaseLayer(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 162 template <typename ReturnT> 163 class DoNothingAndReturn { 164 public: 165 DoNothingAndReturn(ReturnT Val) : Val(Val) {} 166 167 template <typename... Args> 168 ReturnT operator()(Args...) const { return Val; } 169 private: 170 ReturnT Val; 171 }; 172 173 template <> 174 class DoNothingAndReturn<void> { 175 public: 176 template <typename... Args> 177 void operator()(Args...) const { } 178 }; 179 180 } // namespace llvm 181 182 #endif 183