6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-28 04:33:05 +00:00
Code Issues Projects Releases Wiki Activity
4442b6ec3a
llvm-6502/unittests/ExecutionEngine/MCJIT/MCJITTestBase.h
Chandler Carruth 974a445bd9 Re-sort all of the includes with ./utils/sort_includes.py so that 
subsequent changes are easier to review. About to fix some layering
issues, and wanted to separate out the necessary churn.

Also comment and sink the include of "Windows.h" in three .inc files to
match the usage in Memory.inc.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@198685 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-07 11:48:04 +00:00

354 lines
13 KiB
C++
Raw Blame History

//===- MCJITTestBase.h - Common base class for MCJIT Unit tests ----------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This class implements common functionality required by the MCJIT unit tests,
// as well as logic to skip tests on unsupported architectures and operating
// systems.
//
//===----------------------------------------------------------------------===//
#ifndef MCJIT_TEST_BASE_H
#define MCJIT_TEST_BASE_H
#include "MCJITTestAPICommon.h"
#include "llvm/Config/config.h"
#include "llvm/ExecutionEngine/ExecutionEngine.h"
#include "llvm/ExecutionEngine/SectionMemoryManager.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/TypeBuilder.h"
#include "llvm/Support/CodeGen.h"
namespace llvm {
/// Helper class that can build very simple Modules
class TrivialModuleBuilder {
protected:
LLVMContext Context;
IRBuilder<> Builder;
std::string BuilderTriple;
TrivialModuleBuilder(const std::string &Triple)
: Builder(Context), BuilderTriple(Triple) {}
Module *createEmptyModule(StringRef Name = StringRef()) {
Module * M = new Module(Name, Context);
M->setTargetTriple(Triple::normalize(BuilderTriple));
return M;
}
template<typename FuncType>
Function *startFunction(Module *M, StringRef Name) {
Function *Result = Function::Create(
TypeBuilder<FuncType, false>::get(Context),
GlobalValue::ExternalLinkage, Name, M);
BasicBlock *BB = BasicBlock::Create(Context, Name, Result);
Builder.SetInsertPoint(BB);
return Result;
}
void endFunctionWithRet(Function *Func, Value *RetValue) {
Builder.CreateRet(RetValue);
}
// Inserts a simple function that invokes Callee and takes the same arguments:
// int Caller(...) { return Callee(...); }
template<typename Signature>
Function *insertSimpleCallFunction(Module *M, Function *Callee) {
Function *Result = startFunction<Signature>(M, "caller");
SmallVector<Value*, 1> CallArgs;
Function::arg_iterator arg_iter = Result->arg_begin();
for(;arg_iter != Result->arg_end(); ++arg_iter)
CallArgs.push_back(arg_iter);
Value *ReturnCode = Builder.CreateCall(Callee, CallArgs);
Builder.CreateRet(ReturnCode);
return Result;
}
// Inserts a function named 'main' that returns a uint32_t:
// int32_t main() { return X; }
// where X is given by returnCode
Function *insertMainFunction(Module *M, uint32_t returnCode) {
Function *Result = startFunction<int32_t(void)>(M, "main");
Value *ReturnVal = ConstantInt::get(Context, APInt(32, returnCode));
endFunctionWithRet(Result, ReturnVal);
return Result;
}
// Inserts a function
// int32_t add(int32_t a, int32_t b) { return a + b; }
// in the current module and returns a pointer to it.
Function *insertAddFunction(Module *M, StringRef Name = "add") {
Function *Result = startFunction<int32_t(int32_t, int32_t)>(M, Name);
Function::arg_iterator args = Result->arg_begin();
Value *Arg1 = args;
Value *Arg2 = ++args;
Value *AddResult = Builder.CreateAdd(Arg1, Arg2);
endFunctionWithRet(Result, AddResult);
return Result;
}
// Inserts an declaration to a function defined elsewhere
Function *insertExternalReferenceToFunction(Module *M, StringRef Name,
FunctionType *FuncTy) {
Function *Result = Function::Create(FuncTy,
GlobalValue::ExternalLinkage,
Name, M);
return Result;
}
// Inserts an declaration to a function defined elsewhere
Function *insertExternalReferenceToFunction(Module *M, Function *Func) {
Function *Result = Function::Create(Func->getFunctionType(),
GlobalValue::ExternalLinkage,
Func->getName(), M);
return Result;
}
// Inserts a global variable of type int32
// FIXME: make this a template function to support any type
GlobalVariable *insertGlobalInt32(Module *M,
StringRef name,
int32_t InitialValue) {
Type *GlobalTy = TypeBuilder<types::i<32>, true>::get(Context);
Constant *IV = ConstantInt::get(Context, APInt(32, InitialValue));
GlobalVariable *Global = new GlobalVariable(*M,
GlobalTy,
false,
GlobalValue::ExternalLinkage,
IV,
name);
return Global;
}
// Inserts a function
// int32_t recursive_add(int32_t num) {
// if (num == 0) {
// return num;
// } else {
// int32_t recursive_param = num - 1;
// return num + Helper(recursive_param);
// }
// }
// NOTE: if Helper is left as the default parameter, Helper == recursive_add.
Function *insertAccumulateFunction(Module *M,
Function *Helper = 0,
StringRef Name = "accumulate") {
Function *Result = startFunction<int32_t(int32_t)>(M, Name);
if (Helper == 0)
Helper = Result;
BasicBlock *BaseCase = BasicBlock::Create(Context, "", Result);
BasicBlock *RecursiveCase = BasicBlock::Create(Context, "", Result);
// if (num == 0)
Value *Param = Result->arg_begin();
Value *Zero = ConstantInt::get(Context, APInt(32, 0));
Builder.CreateCondBr(Builder.CreateICmpEQ(Param, Zero),
BaseCase, RecursiveCase);
// return num;
Builder.SetInsertPoint(BaseCase);
Builder.CreateRet(Param);
// int32_t recursive_param = num - 1;
// return Helper(recursive_param);
Builder.SetInsertPoint(RecursiveCase);
Value *One = ConstantInt::get(Context, APInt(32, 1));
Value *RecursiveParam = Builder.CreateSub(Param, One);
Value *RecursiveReturn = Builder.CreateCall(Helper, RecursiveParam);
Value *Accumulator = Builder.CreateAdd(Param, RecursiveReturn);
Builder.CreateRet(Accumulator);
return Result;
}
// Populates Modules A and B:
// Module A { Extern FB1, Function FA which calls FB1 },
// Module B { Extern FA, Function FB1, Function FB2 which calls FA },
void createCrossModuleRecursiveCase(OwningPtr<Module> &A,
Function *&FA,
OwningPtr<Module> &B,
Function *&FB1,
Function *&FB2) {
// Define FB1 in B.
B.reset(createEmptyModule("B"));
FB1 = insertAccumulateFunction(B.get(), 0, "FB1");
// Declare FB1 in A (as an external).
A.reset(createEmptyModule("A"));
Function *FB1Extern = insertExternalReferenceToFunction(A.get(), FB1);
// Define FA in A (with a call to FB1).
FA = insertAccumulateFunction(A.get(), FB1Extern, "FA");
// Declare FA in B (as an external)
Function *FAExtern = insertExternalReferenceToFunction(B.get(), FA);
// Define FB2 in B (with a call to FA)
FB2 = insertAccumulateFunction(B.get(), FAExtern, "FB2");
}
// Module A { Function FA },
// Module B { Extern FA, Function FB which calls FA },
// Module C { Extern FB, Function FC which calls FB },
void createThreeModuleChainedCallsCase(OwningPtr<Module> &A,
Function *&FA,
OwningPtr<Module> &B,
Function *&FB,
OwningPtr<Module> &C,
Function *&FC) {
A.reset(createEmptyModule("A"));
FA = insertAddFunction(A.get());
B.reset(createEmptyModule("B"));
Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA);
FB = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(B.get(), FAExtern_in_B);
C.reset(createEmptyModule("C"));
Function *FBExtern_in_C = insertExternalReferenceToFunction(C.get(), FB);
FC = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(C.get(), FBExtern_in_C);
}
// Module A { Function FA },
// Populates Modules A and B:
// Module B { Function FB }
void createTwoModuleCase(OwningPtr<Module> &A, Function *&FA,
OwningPtr<Module> &B, Function *&FB) {
A.reset(createEmptyModule("A"));
FA = insertAddFunction(A.get());
B.reset(createEmptyModule("B"));
FB = insertAddFunction(B.get());
}
// Module A { Function FA },
// Module B { Extern FA, Function FB which calls FA }
void createTwoModuleExternCase(OwningPtr<Module> &A, Function *&FA,
OwningPtr<Module> &B, Function *&FB) {
A.reset(createEmptyModule("A"));
FA = insertAddFunction(A.get());
B.reset(createEmptyModule("B"));
Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA);
FB = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(B.get(),
FAExtern_in_B);
}
// Module A { Function FA },
// Module B { Extern FA, Function FB which calls FA },
// Module C { Extern FB, Function FC which calls FA },
void createThreeModuleCase(OwningPtr<Module> &A,
Function *&FA,
OwningPtr<Module> &B,
Function *&FB,
OwningPtr<Module> &C,
Function *&FC) {
A.reset(createEmptyModule("A"));
FA = insertAddFunction(A.get());
B.reset(createEmptyModule("B"));
Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA);
FB = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(B.get(), FAExtern_in_B);
C.reset(createEmptyModule("C"));
Function *FAExtern_in_C = insertExternalReferenceToFunction(C.get(), FA);
FC = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(C.get(), FAExtern_in_C);
}
};
class MCJITTestBase : public MCJITTestAPICommon, public TrivialModuleBuilder {
protected:
MCJITTestBase()
: TrivialModuleBuilder(HostTriple)
, OptLevel(CodeGenOpt::None)
, RelocModel(Reloc::Default)
, CodeModel(CodeModel::Default)
, MArch("")
, MM(new SectionMemoryManager)
{
// The architectures below are known to be compatible with MCJIT as they
// are copied from test/ExecutionEngine/MCJIT/lit.local.cfg and should be
// kept in sync.
SupportedArchs.push_back(Triple::aarch64);
SupportedArchs.push_back(Triple::arm);
SupportedArchs.push_back(Triple::mips);
SupportedArchs.push_back(Triple::mipsel);
SupportedArchs.push_back(Triple::x86);
SupportedArchs.push_back(Triple::x86_64);
// Some architectures have sub-architectures in which tests will fail, like
// ARM. These two vectors will define if they do have sub-archs (to avoid
// extra work for those who don't), and if so, if they are listed to work
HasSubArchs.push_back(Triple::arm);
SupportedSubArchs.push_back("armv6");
SupportedSubArchs.push_back("armv7");
// The operating systems below are known to be incompatible with MCJIT as
// they are copied from the test/ExecutionEngine/MCJIT/lit.local.cfg and
// should be kept in sync.
UnsupportedOSs.push_back(Triple::Cygwin);
UnsupportedOSs.push_back(Triple::Darwin);
}
void createJIT(Module *M) {
// Due to the EngineBuilder constructor, it is required to have a Module
// in order to construct an ExecutionEngine (i.e. MCJIT)
assert(M != 0 && "a non-null Module must be provided to create MCJIT");
EngineBuilder EB(M);
std::string Error;
TheJIT.reset(EB.setEngineKind(EngineKind::JIT)
.setUseMCJIT(true) /* can this be folded into the EngineKind enum? */
.setMCJITMemoryManager(MM)
.setErrorStr(&Error)
.setOptLevel(CodeGenOpt::None)
.setAllocateGVsWithCode(false) /*does this do anything?*/
.setCodeModel(CodeModel::JITDefault)
.setRelocationModel(Reloc::Default)
.setMArch(MArch)
.setMCPU(sys::getHostCPUName())
//.setMAttrs(MAttrs)
.create());
// At this point, we cannot modify the module any more.
assert(TheJIT.get() != NULL && "error creating MCJIT with EngineBuilder");
}
CodeGenOpt::Level OptLevel;
Reloc::Model RelocModel;
CodeModel::Model CodeModel;
StringRef MArch;
SmallVector<std::string, 1> MAttrs;
OwningPtr<ExecutionEngine> TheJIT;
RTDyldMemoryManager *MM;
OwningPtr<Module> M;
};
} // namespace llvm
#endif // MCJIT_TEST_H
Reference in New Issue View Git Blame Copy Permalink