Lines Matching +full:helper +full:- +full:function +full:- +full:name
1 //===- MCJITTestBase.h - Common base class for MCJIT Unit tests -*- C++ -*-===//
8 //===----------------------------------------------------------------------===//
14 //===----------------------------------------------------------------------===//
23 #include "llvm/IR/Function.h"
32 /// Helper class that can build very simple Modules
42 Module *createEmptyModule(StringRef Name = StringRef()) {
43 Module * M = new Module(Name, Context);
44 M->setTargetTriple(Triple::normalize(BuilderTriple));
49 Function *startFunction(Module *M, StringRef Name) { in startFunction() argument
50 Function *Result = Function::Create( in startFunction()
52 GlobalValue::ExternalLinkage, Name, M); in startFunction()
54 BasicBlock *BB = BasicBlock::Create(Context, Name, Result); in startFunction()
60 void endFunctionWithRet(Function *Func, Value *RetValue) { in endFunctionWithRet()
64 // Inserts a simple function that invokes Callee and takes the same arguments:
67 Function *insertSimpleCallFunction(Module *M, Function *Callee) { in insertSimpleCallFunction()
68 Function *Result = startFunction<Signature>(M, "caller"); in insertSimpleCallFunction()
72 for (Argument &A : Result->args()) in insertSimpleCallFunction()
80 // Inserts a function named 'main' that returns a uint32_t:
83 Function *insertMainFunction(Module *M, uint32_t returnCode) { in insertMainFunction()
84 Function *Result = startFunction<int32_t(void)>(M, "main"); in insertMainFunction()
92 // Inserts a function
95 Function *insertAddFunction(Module *M, StringRef Name = "add") {
96 Function *Result = startFunction<int32_t(int32_t, int32_t)>(M, Name);
98 Function::arg_iterator args = Result->arg_begin();
108 // Inserts a declaration to a function defined elsewhere
110 Function *insertExternalReferenceToFunction(Module *M, StringRef Name) { in insertExternalReferenceToFunction() argument
111 Function *Result = Function::Create( in insertExternalReferenceToFunction()
113 GlobalValue::ExternalLinkage, Name, M); in insertExternalReferenceToFunction()
117 // Inserts an declaration to a function defined elsewhere
118 Function *insertExternalReferenceToFunction(Module *M, StringRef Name, in insertExternalReferenceToFunction() argument
120 Function *Result = Function::Create(FuncTy, in insertExternalReferenceToFunction()
122 Name, M); in insertExternalReferenceToFunction()
126 // Inserts an declaration to a function defined elsewhere
127 Function *insertExternalReferenceToFunction(Module *M, Function *Func) { in insertExternalReferenceToFunction()
128 Function *Result = Function::Create(Func->getFunctionType(), in insertExternalReferenceToFunction()
130 Func->getName(), M); in insertExternalReferenceToFunction()
135 // FIXME: make this a template function to support any type
137 StringRef name, in insertGlobalInt32() argument
146 name); in insertGlobalInt32()
150 // Inserts a function
155 // int32_t recursive_param = num - 1;
156 // return num + Helper(recursive_param);
159 // NOTE: if Helper is left as the default parameter, Helper == recursive_add.
160 Function *insertAccumulateFunction(Module *M,
161 Function *Helper = nullptr,
162 StringRef Name = "accumulate") {
163 Function *Result = startFunction<int32_t(int32_t)>(M, Name);
164 if (!Helper)
165 Helper = Result;
171 Value *Param = &*Result->arg_begin();
180 // int32_t recursive_param = num - 1;
181 // return Helper(recursive_param);
185 Value *RecursiveReturn = Builder.CreateCall(Helper, RecursiveParam);
193 // Module A { Extern FB1, Function FA which calls FB1 },
194 // Module B { Extern FA, Function FB1, Function FB2 which calls FA },
195 void createCrossModuleRecursiveCase(std::unique_ptr<Module> &A, Function *&FA, in createCrossModuleRecursiveCase()
197 Function *&FB1, Function *&FB2) { in createCrossModuleRecursiveCase()
204 Function *FB1Extern = insertExternalReferenceToFunction(A.get(), FB1); in createCrossModuleRecursiveCase()
210 Function *FAExtern = insertExternalReferenceToFunction(B.get(), FA); in createCrossModuleRecursiveCase()
216 // Module A { Function FA },
217 // Module B { Extern FA, Function FB which calls FA },
218 // Module C { Extern FB, Function FC which calls FB },
220 createThreeModuleChainedCallsCase(std::unique_ptr<Module> &A, Function *&FA, in createThreeModuleChainedCallsCase()
221 std::unique_ptr<Module> &B, Function *&FB, in createThreeModuleChainedCallsCase()
222 std::unique_ptr<Module> &C, Function *&FC) { in createThreeModuleChainedCallsCase()
227 Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA); in createThreeModuleChainedCallsCase()
231 Function *FBExtern_in_C = insertExternalReferenceToFunction(C.get(), FB); in createThreeModuleChainedCallsCase()
235 // Module A { Function FA },
237 // Module B { Function FB }
238 void createTwoModuleCase(std::unique_ptr<Module> &A, Function *&FA, in createTwoModuleCase()
239 std::unique_ptr<Module> &B, Function *&FB) { in createTwoModuleCase()
247 // Module A { Function FA },
248 // Module B { Extern FA, Function FB which calls FA }
249 void createTwoModuleExternCase(std::unique_ptr<Module> &A, Function *&FA, in createTwoModuleExternCase()
250 std::unique_ptr<Module> &B, Function *&FB) { in createTwoModuleExternCase()
255 Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA); in createTwoModuleExternCase()
260 // Module A { Function FA },
261 // Module B { Extern FA, Function FB which calls FA },
262 // Module C { Extern FB, Function FC which calls FA },
263 void createThreeModuleCase(std::unique_ptr<Module> &A, Function *&FA, in createThreeModuleCase()
264 std::unique_ptr<Module> &B, Function *&FB, in createThreeModuleCase()
265 std::unique_ptr<Module> &C, Function *&FC) { in createThreeModuleCase()
270 Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA); in createThreeModuleCase()
274 Function *FAExtern_in_C = insertExternalReferenceToFunction(C.get(), FA); in createThreeModuleCase()
301 // Some architectures have sub-architectures in which tests will fail, like in MCJITTestBase()
302 // ARM. These two vectors will define if they do have sub-archs (to avoid in MCJITTestBase()
315 assert(M != 0 && "a non-null Module must be provided to create MCJIT"); in createJIT()