void ASTInfo::code_gen(llvm::Module *M, llvm::IRBuilder<> &B)
{
llvm::LLVMContext &context = M->getContext();
if (!__brain_index_ptr) {
// Create global variable |brain.index|
llvm::Type *Ty = llvm::Type::getInt32Ty(context);
const llvm::APInt Zero = llvm::APInt(32, 0); // int32 0
llvm::Constant *InitV = llvm::Constant::getIntegerValue(Ty, Zero);
ASTInfo::__brain_index_ptr = new llvm::GlobalVariable(*M, Ty, false,
// Keep one copy when linking (weak)
llvm::GlobalValue::WeakAnyLinkage,
InitV,
"brain.index");
}
if (!__brain_cells_ptr) {
// Create |brain.cells|
auto *ArrTy = llvm::ArrayType::get(llvm::Type::getInt32Ty(context),
ArgsOptions::instance()->get_cells_size());
// Create a vector of _k_cells_size items equal to 0
std::vector<llvm::Constant *> constants(ArgsOptions::instance()->get_cells_size(),
B.getInt32(0));
llvm::ArrayRef<llvm::Constant *> Constants = llvm::ArrayRef<llvm::Constant *>(constants);
llvm::Constant *InitPtr = llvm::ConstantArray::get(ArrTy, Constants);
ASTInfo::__brain_cells_ptr = new llvm::GlobalVariable(*M, ArrTy, false,
// Keep one copy when linking (weak)
llvm::GlobalValue::WeakAnyLinkage,
InitPtr,
"brain.cells");
}
}
void Simulator::Simulate()
{
llvm::SMDiagnostic error;
//std::unique_ptr<llvm::Module> M = llvm::ParseIRFile("Behavior.bc", error, context);
//MyModule = M.get();
MyModule = llvm::ParseIRFile("Behavior.bc", error, context);
string err_str;
/*
OwningPtr<MemoryBuffer> result;
MemoryBuffer *mb;
llvm::error_code ec = MemoryBuffer::getFile("Behavior.bc", result);
mb = result.take();
err_str = ec.message();
if (!mb) {
error() <<"Cannot open \"" <<bitcode_file() <<"\": " <<err_str <<endl;
exit(1);
}
MyModule = llvm::ParseBitcodeFile(mb,context,&err_str);
if (!MyModule) {
error() <<"Failed to load module from bitcode file: " <<err_str <<endl;
exit(1);
}
delete mb;
*/
/*
for (llvm::Module::iterator f = MyModule->begin(), ef = MyModule->end(); f!=ef; ++f)
{
f->addFnAttr(Attributes::AlwaysInline);
}
*/
for (int32_t i = 0; i < (int32_t)OPCODE::INVALID; i++) {
OPCODE op = (OPCODE) i;
llvm::Function *func = MyModule->getFunction(GetFuncName(op));
func->addFnAttr(llvm::Attribute::AlwaysInline);
OpFunctionMap[op] = func;
}
test_type = MyModule->getFunction("test")->getFunctionType();
std::string ErrStr;
passManager = new llvm::PassManager();
passManager->add(llvm::createAlwaysInlinerPass());
fPassManager = new llvm::FunctionPassManager(MyModule);
//fPassManager->add(new DataLayout(*EE->getDataLayout()));
//fPassManager->add(new DataLayout(*EE->getDataLayout()));
fPassManager->add(llvm::createGVNPass());
fPassManager->add(llvm::createInstructionCombiningPass());
fPassManager->add(llvm::createCFGSimplificationPass());
fPassManager->add(llvm::createDeadStoreEliminationPass());
/*
llvm::EngineBuilder builder(MyModule);
builder.setErrorStr(&ErrStr);
builder.setEngineKind(llvm::EngineKind::JIT);
builder.setOptLevel(llvm::CodeGenOpt::Default); // None/Less/Default/Aggressive
//llvm::TargetOptions options;
//options.JITExceptionHandling = 1;
//builder.setTargetOptions(options);
EE = builder.create();
*/
//StringRef MCPU = llvm::sys::getHostCPUName()
EE = llvm::EngineBuilder(MyModule).create();
/*
EE =
llvm::EngineBuilder(std::move(M))
.setErrorStr(&ErrStr)
.setMCJITMemoryManager(llvm::make_unique<llvm::SectionMemoryManager>())
.create();
*/
/*
EE = llvm::EngineBuilder(M)
.setErrorStr(&ErrStr)
.setMCJITMemoryManager(llvm::SectionMemoryManager())
.create();
EE = llvm::EngineBuilder(std::move(M)).setErrorStr(&ErrStr).create();
*/
if (!EE) {
fprintf(stderr, "Could not create ExecutionEngine: %s\n", ErrStr.c_str());
exit(1);
}
EE->DisableLazyCompilation(true);
/*
//atexit(llvm_shutdown); // Call llvm_shutdown() on exit.
//llvm::EngineBuilder builder(MyModule);
llvm::EngineBuilder builder(std::move(M));
//llvm::EngineBuilder builder(MyModule);
builder.setErrorStr(&err_str);
builder.setEngineKind(llvm::EngineKind::JIT);
builder.setOptLevel(llvm::CodeGenOpt::Default); // None/Less/Default/Aggressive
//TargetOptions options;
//options.JITExceptionHandling = 1;
//builder.setTargetOptions(options);
EE = builder.create();
if (!EE) {
std::cout <<"failed to create execution engine: " <<err_str <<"\n";
exit(1);
}
*/
/*
//MyModule->dump();
EE = llvm::EngineBuilder(std::move(M)).create();
*/
//string ErrStr;
//EE = llvm::EngineBuilder(std::move(M)).setErrorStr(&ErrStr).setMCPU("i386").create();
//context = llvm::getGlobalContext();
int32_t index = 0;
Blocks = new HostBlock[1000];
int32_t block_index = 0;
while(index < total_inst) {
Blocks[block_index].pc = index;
ostringstream f_name;
f_name << "func";
f_name << block_index;
//string f_name = string("func");// + string(index);
/*
llvm::Function *func =
llvm::cast<llvm::Function>(MyModule->getOrInsertFunction(f_name.str(),
llvm::Type::getVoidTy(context), (llvm::Type *)0));
*/
// Make the function type: double(double,double) etc.
//std::vector<Type*> Doubles(Args.size(),
// Type::getDoubleTy(getGlobalContext()));
llvm::FunctionType *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(context), false);
llvm::Function *func = llvm::Function::Create(FT,
llvm::Function::ExternalLinkage,
f_name.str(),
MyModule);
//Function *F = Function::Create(FT, Function::ExternalLinkage, FnName, M);
// Add a basic block to the function. As before, it automatically inserts
// because of the last argument.
llvm::BasicBlock *BB = llvm::BasicBlock::Create(context, "EntryBlock", func);
// Create a basic block builder with default parameters. The builder will
// automatically append instructions to the basic block `BB'.
IRB.SetInsertPoint(BB);
llvm::Function *sim_func;
CInst *inst;
int b_size = 0;
do {
inst = &instructions[index];
llvm::Value *dst = IRB.getInt32(inst->dst_reg);
llvm::Value *src0 = IRB.getInt32(inst->src0_reg);
llvm::Value *src1 = IRB.getInt32(inst->src1_reg);
sim_func = OpFunctionMap[inst->opcode];
llvm::Value *oprnds[] = {dst, src0, src1};
llvm::ArrayRef <llvm::Value *> ref(oprnds, 3);
IRB.CreateCall(sim_func, ref);
index++;
b_size++;
//cout << "Index " << index << endl;
//} while(b_size < 10 || inst->opcode != OPCODE::JMP);
} while(b_size < 10 && index < total_inst);
IRB.CreateRetVoid();
passManager->run(*MyModule);
fPassManager->run(*func);
EE->finalizeObject();
//std::vector<llvm::GenericValue> noargs;
//std::cout << "calling " << f_name.str() << endl;
//EE->runFunction(func, noargs);
//Blocks[block_index].func_ptr = reinterpret_cast<HostFunction>(EE->getPointerToFunction(func));
Blocks[block_index].func_ptr = (void *)(EE->getPointerToFunction(func));
//Blocks[block_index].func_ptr = reinterpret_cast<decltype(HostFunction())>(EE->getPointerToNamedFunction(f_name.str()));
//(Blocks[block_index].func_ptr)();
block_index++;
//cout << "BlockIndex " << block_index << endl;
}
total_blocks = block_index;
MyModule->dump();
/*
cout << "calling add32" << endl;
void (*add32)(int32_t, int32_t, int32_t) =
reinterpret_cast<void (*)(int32_t, int32_t, int32_t)>(EE->getFunctionAddress("add32"));
add32(0, 2, 3);
*/
/*
void (*func0)() =
reinterpret_cast<void (*)()>(EE->getFunctionAddress("func1"));
func0();
*/
/*
struct timeval tp;
gettimeofday(&tp, NULL);
long int start = tp.tv_sec * 1000 + tp.tv_usec / 1000;
for (int32_t i = 0; i < 100; i++) {
for (int32_t j = 0 ; j < total_blocks; j++) {
((HostFunction)(Blocks[j].func_ptr))();
}
}
gettimeofday(&tp, NULL);
long int end = tp.tv_sec * 1000 + tp.tv_usec / 1000;
cout << "Time = " << end - start << endl;
*/
}