1 //===- MCJITTestBase.h - Common base class for MCJIT Unit tests ----------===// 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 // This class implements common functionality required by the MCJIT unit tests, 11 // as well as logic to skip tests on unsupported architectures and operating 12 // systems. 13 // 14 //===----------------------------------------------------------------------===// 15 16 17 #ifndef MCJIT_TEST_BASE_H 18 #define MCJIT_TEST_BASE_H 19 20 #include "MCJITTestAPICommon.h" 21 #include "llvm/Config/config.h" 22 #include "llvm/ExecutionEngine/ExecutionEngine.h" 23 #include "llvm/ExecutionEngine/SectionMemoryManager.h" 24 #include "llvm/IR/Function.h" 25 #include "llvm/IR/IRBuilder.h" 26 #include "llvm/IR/LLVMContext.h" 27 #include "llvm/IR/Module.h" 28 #include "llvm/IR/TypeBuilder.h" 29 #include "llvm/Support/CodeGen.h" 30 31 namespace llvm { 32 33 /// Helper class that can build very simple Modules 34 class TrivialModuleBuilder { 35 protected: 36 LLVMContext Context; 37 IRBuilder<> Builder; 38 std::string BuilderTriple; 39 40 TrivialModuleBuilder(const std::string &Triple) 41 : Builder(Context), BuilderTriple(Triple) {} 42 43 Module *createEmptyModule(StringRef Name = StringRef()) { 44 Module * M = new Module(Name, Context); 45 M->setTargetTriple(Triple::normalize(BuilderTriple)); 46 return M; 47 } 48 49 template<typename FuncType> 50 Function *startFunction(Module *M, StringRef Name) { 51 Function *Result = Function::Create( 52 TypeBuilder<FuncType, false>::get(Context), 53 GlobalValue::ExternalLinkage, Name, M); 54 55 BasicBlock *BB = BasicBlock::Create(Context, Name, Result); 56 Builder.SetInsertPoint(BB); 57 58 return Result; 59 } 60 61 void endFunctionWithRet(Function *Func, Value *RetValue) { 62 Builder.CreateRet(RetValue); 63 } 64 65 // Inserts a simple function that invokes Callee and takes the same arguments: 66 // int Caller(...) { return Callee(...); } 67 template<typename Signature> 68 Function *insertSimpleCallFunction(Module *M, Function *Callee) { 69 Function *Result = startFunction<Signature>(M, "caller"); 70 71 SmallVector<Value*, 1> CallArgs; 72 73 Function::arg_iterator arg_iter = Result->arg_begin(); 74 for(;arg_iter != Result->arg_end(); ++arg_iter) 75 CallArgs.push_back(arg_iter); 76 77 Value *ReturnCode = Builder.CreateCall(Callee, CallArgs); 78 Builder.CreateRet(ReturnCode); 79 return Result; 80 } 81 82 // Inserts a function named 'main' that returns a uint32_t: 83 // int32_t main() { return X; } 84 // where X is given by returnCode 85 Function *insertMainFunction(Module *M, uint32_t returnCode) { 86 Function *Result = startFunction<int32_t(void)>(M, "main"); 87 88 Value *ReturnVal = ConstantInt::get(Context, APInt(32, returnCode)); 89 endFunctionWithRet(Result, ReturnVal); 90 91 return Result; 92 } 93 94 // Inserts a function 95 // int32_t add(int32_t a, int32_t b) { return a + b; } 96 // in the current module and returns a pointer to it. 97 Function *insertAddFunction(Module *M, StringRef Name = "add") { 98 Function *Result = startFunction<int32_t(int32_t, int32_t)>(M, Name); 99 100 Function::arg_iterator args = Result->arg_begin(); 101 Value *Arg1 = args; 102 Value *Arg2 = ++args; 103 Value *AddResult = Builder.CreateAdd(Arg1, Arg2); 104 105 endFunctionWithRet(Result, AddResult); 106 107 return Result; 108 } 109 110 // Inserts an declaration to a function defined elsewhere 111 Function *insertExternalReferenceToFunction(Module *M, StringRef Name, 112 FunctionType *FuncTy) { 113 Function *Result = Function::Create(FuncTy, 114 GlobalValue::ExternalLinkage, 115 Name, M); 116 return Result; 117 } 118 119 // Inserts an declaration to a function defined elsewhere 120 Function *insertExternalReferenceToFunction(Module *M, Function *Func) { 121 Function *Result = Function::Create(Func->getFunctionType(), 122 GlobalValue::ExternalLinkage, 123 Func->getName(), M); 124 return Result; 125 } 126 127 // Inserts a global variable of type int32 128 // FIXME: make this a template function to support any type 129 GlobalVariable *insertGlobalInt32(Module *M, 130 StringRef name, 131 int32_t InitialValue) { 132 Type *GlobalTy = TypeBuilder<types::i<32>, true>::get(Context); 133 Constant *IV = ConstantInt::get(Context, APInt(32, InitialValue)); 134 GlobalVariable *Global = new GlobalVariable(*M, 135 GlobalTy, 136 false, 137 GlobalValue::ExternalLinkage, 138 IV, 139 name); 140 return Global; 141 } 142 143 // Inserts a function 144 // int32_t recursive_add(int32_t num) { 145 // if (num == 0) { 146 // return num; 147 // } else { 148 // int32_t recursive_param = num - 1; 149 // return num + Helper(recursive_param); 150 // } 151 // } 152 // NOTE: if Helper is left as the default parameter, Helper == recursive_add. 153 Function *insertAccumulateFunction(Module *M, 154 Function *Helper = 0, 155 StringRef Name = "accumulate") { 156 Function *Result = startFunction<int32_t(int32_t)>(M, Name); 157 if (Helper == 0) 158 Helper = Result; 159 160 BasicBlock *BaseCase = BasicBlock::Create(Context, "", Result); 161 BasicBlock *RecursiveCase = BasicBlock::Create(Context, "", Result); 162 163 // if (num == 0) 164 Value *Param = Result->arg_begin(); 165 Value *Zero = ConstantInt::get(Context, APInt(32, 0)); 166 Builder.CreateCondBr(Builder.CreateICmpEQ(Param, Zero), 167 BaseCase, RecursiveCase); 168 169 // return num; 170 Builder.SetInsertPoint(BaseCase); 171 Builder.CreateRet(Param); 172 173 // int32_t recursive_param = num - 1; 174 // return Helper(recursive_param); 175 Builder.SetInsertPoint(RecursiveCase); 176 Value *One = ConstantInt::get(Context, APInt(32, 1)); 177 Value *RecursiveParam = Builder.CreateSub(Param, One); 178 Value *RecursiveReturn = Builder.CreateCall(Helper, RecursiveParam); 179 Value *Accumulator = Builder.CreateAdd(Param, RecursiveReturn); 180 Builder.CreateRet(Accumulator); 181 182 return Result; 183 } 184 185 // Populates Modules A and B: 186 // Module A { Extern FB1, Function FA which calls FB1 }, 187 // Module B { Extern FA, Function FB1, Function FB2 which calls FA }, 188 void createCrossModuleRecursiveCase(std::unique_ptr<Module> &A, Function *&FA, 189 std::unique_ptr<Module> &B, 190 Function *&FB1, Function *&FB2) { 191 // Define FB1 in B. 192 B.reset(createEmptyModule("B")); 193 FB1 = insertAccumulateFunction(B.get(), 0, "FB1"); 194 195 // Declare FB1 in A (as an external). 196 A.reset(createEmptyModule("A")); 197 Function *FB1Extern = insertExternalReferenceToFunction(A.get(), FB1); 198 199 // Define FA in A (with a call to FB1). 200 FA = insertAccumulateFunction(A.get(), FB1Extern, "FA"); 201 202 // Declare FA in B (as an external) 203 Function *FAExtern = insertExternalReferenceToFunction(B.get(), FA); 204 205 // Define FB2 in B (with a call to FA) 206 FB2 = insertAccumulateFunction(B.get(), FAExtern, "FB2"); 207 } 208 209 // Module A { Function FA }, 210 // Module B { Extern FA, Function FB which calls FA }, 211 // Module C { Extern FB, Function FC which calls FB }, 212 void 213 createThreeModuleChainedCallsCase(std::unique_ptr<Module> &A, Function *&FA, 214 std::unique_ptr<Module> &B, Function *&FB, 215 std::unique_ptr<Module> &C, Function *&FC) { 216 A.reset(createEmptyModule("A")); 217 FA = insertAddFunction(A.get()); 218 219 B.reset(createEmptyModule("B")); 220 Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA); 221 FB = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(B.get(), FAExtern_in_B); 222 223 C.reset(createEmptyModule("C")); 224 Function *FBExtern_in_C = insertExternalReferenceToFunction(C.get(), FB); 225 FC = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(C.get(), FBExtern_in_C); 226 } 227 228 229 // Module A { Function FA }, 230 // Populates Modules A and B: 231 // Module B { Function FB } 232 void createTwoModuleCase(std::unique_ptr<Module> &A, Function *&FA, 233 std::unique_ptr<Module> &B, Function *&FB) { 234 A.reset(createEmptyModule("A")); 235 FA = insertAddFunction(A.get()); 236 237 B.reset(createEmptyModule("B")); 238 FB = insertAddFunction(B.get()); 239 } 240 241 // Module A { Function FA }, 242 // Module B { Extern FA, Function FB which calls FA } 243 void createTwoModuleExternCase(std::unique_ptr<Module> &A, Function *&FA, 244 std::unique_ptr<Module> &B, Function *&FB) { 245 A.reset(createEmptyModule("A")); 246 FA = insertAddFunction(A.get()); 247 248 B.reset(createEmptyModule("B")); 249 Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA); 250 FB = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(B.get(), 251 FAExtern_in_B); 252 } 253 254 // Module A { Function FA }, 255 // Module B { Extern FA, Function FB which calls FA }, 256 // Module C { Extern FB, Function FC which calls FA }, 257 void createThreeModuleCase(std::unique_ptr<Module> &A, Function *&FA, 258 std::unique_ptr<Module> &B, Function *&FB, 259 std::unique_ptr<Module> &C, Function *&FC) { 260 A.reset(createEmptyModule("A")); 261 FA = insertAddFunction(A.get()); 262 263 B.reset(createEmptyModule("B")); 264 Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA); 265 FB = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(B.get(), FAExtern_in_B); 266 267 C.reset(createEmptyModule("C")); 268 Function *FAExtern_in_C = insertExternalReferenceToFunction(C.get(), FA); 269 FC = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(C.get(), FAExtern_in_C); 270 } 271 }; 272 273 274 class MCJITTestBase : public MCJITTestAPICommon, public TrivialModuleBuilder { 275 protected: 276 277 MCJITTestBase() 278 : TrivialModuleBuilder(HostTriple) 279 , OptLevel(CodeGenOpt::None) 280 , RelocModel(Reloc::Default) 281 , CodeModel(CodeModel::Default) 282 , MArch("") 283 , MM(new SectionMemoryManager) 284 { 285 // The architectures below are known to be compatible with MCJIT as they 286 // are copied from test/ExecutionEngine/MCJIT/lit.local.cfg and should be 287 // kept in sync. 288 SupportedArchs.push_back(Triple::aarch64); 289 SupportedArchs.push_back(Triple::arm); 290 SupportedArchs.push_back(Triple::mips); 291 SupportedArchs.push_back(Triple::mipsel); 292 SupportedArchs.push_back(Triple::x86); 293 SupportedArchs.push_back(Triple::x86_64); 294 295 // Some architectures have sub-architectures in which tests will fail, like 296 // ARM. These two vectors will define if they do have sub-archs (to avoid 297 // extra work for those who don't), and if so, if they are listed to work 298 HasSubArchs.push_back(Triple::arm); 299 SupportedSubArchs.push_back("armv6"); 300 SupportedSubArchs.push_back("armv7"); 301 302 // The operating systems below are known to be incompatible with MCJIT as 303 // they are copied from the test/ExecutionEngine/MCJIT/lit.local.cfg and 304 // should be kept in sync. 305 UnsupportedOSs.push_back(Triple::Cygwin); 306 UnsupportedOSs.push_back(Triple::Darwin); 307 308 UnsupportedEnvironments.push_back(Triple::Cygnus); 309 } 310 311 void createJIT(Module *M) { 312 313 // Due to the EngineBuilder constructor, it is required to have a Module 314 // in order to construct an ExecutionEngine (i.e. MCJIT) 315 assert(M != 0 && "a non-null Module must be provided to create MCJIT"); 316 317 EngineBuilder EB(M); 318 std::string Error; 319 TheJIT.reset(EB.setEngineKind(EngineKind::JIT) 320 .setUseMCJIT(true) /* can this be folded into the EngineKind enum? */ 321 .setMCJITMemoryManager(MM) 322 .setErrorStr(&Error) 323 .setOptLevel(CodeGenOpt::None) 324 .setAllocateGVsWithCode(false) /*does this do anything?*/ 325 .setCodeModel(CodeModel::JITDefault) 326 .setRelocationModel(Reloc::Default) 327 .setMArch(MArch) 328 .setMCPU(sys::getHostCPUName()) 329 //.setMAttrs(MAttrs) 330 .create()); 331 // At this point, we cannot modify the module any more. 332 assert(TheJIT.get() != NULL && "error creating MCJIT with EngineBuilder"); 333 } 334 335 CodeGenOpt::Level OptLevel; 336 Reloc::Model RelocModel; 337 CodeModel::Model CodeModel; 338 StringRef MArch; 339 SmallVector<std::string, 1> MAttrs; 340 std::unique_ptr<ExecutionEngine> TheJIT; 341 RTDyldMemoryManager *MM; 342 343 std::unique_ptr<Module> M; 344 }; 345 346 } // namespace llvm 347 348 #endif // MCJIT_TEST_H 349
