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