Value* While::codeGen(CodeGenContext &context) {
//Value* conditionValue = condition.codeGen(context);
IRBuilder<> *builder = context.currentBuilder();
Function *mainFunction = builder->GetInsertBlock()->getParent();
BasicBlock *condBb = BasicBlock::Create(getGlobalContext(), "whilecond",
mainFunction);
BasicBlock *doBb = BasicBlock::Create(getGlobalContext(), "whiledo");
BasicBlock *afterWhileBb = BasicBlock::Create(getGlobalContext(), "afterWhile");
builder->CreateBr(condBb);
builder->SetInsertPoint(condBb);
Value* conditionValue = condition.codeGen(context);
builder->CreateCondBr(conditionValue, doBb, afterWhileBb);
condBb = builder->GetInsertBlock();
mainFunction->getBasicBlockList().push_back(doBb);
builder->SetInsertPoint(doBb);
Value *doValue = (*doStmt).codeGen(context);
builder->CreateBr(condBb);
doBb = builder->GetInsertBlock();
mainFunction->getBasicBlockList().push_back(afterWhileBb);
builder->SetInsertPoint(afterWhileBb);
return NULL;
}
void MmixLlvm::Private::emitIncl(VerticeContext& vctx, IRBuilder<>& builder, MXByte xarg, MXWyde yzarg)
{
Value *xval0 = vctx.getRegister(xarg);
Value* result = builder.CreateAdd(xval0, builder.getInt64((MXOcta) yzarg));
assignRegister(vctx, builder, xarg, result);
builder.CreateBr(vctx.getOCExit());
}
/// compile_back - Emit code for ']'
void BrainFTraceRecorder::compile_back(BrainFTraceNode *node,
IRBuilder<>& builder) {
if (node->right != (BrainFTraceNode*)~0ULL)
compile_opcode(node->right, builder);
else {
HeaderPHI->addIncoming(DataPtr, builder.GetInsertBlock());
builder.CreateBr(Header);
}
}
Value* If::codeGen(CodeGenContext &context) {
Value* conditionValue = condition.codeGen(context);
IRBuilder<> *builder = context.currentBuilder();
Function *mainFunction = builder->GetInsertBlock()->getParent();
BasicBlock *thenBb = BasicBlock::Create(getGlobalContext(), "then",
mainFunction);
BasicBlock *mergeBb = BasicBlock::Create(getGlobalContext(), "ifcont");
BasicBlock *elseBb = BasicBlock::Create(getGlobalContext(), "else");
if (elseStmt == NULL) {
std::cout << "Creating if then " << endl;
builder->CreateCondBr(conditionValue, thenBb, mergeBb);
builder->SetInsertPoint(thenBb);
Value *thenValue = (*thenStmt).codeGen(context);
builder->CreateBr(mergeBb);
thenBb = builder->GetInsertBlock();
mainFunction->getBasicBlockList().push_back(mergeBb);
builder->SetInsertPoint(mergeBb);
return NULL;
} else {
cout << "Creating if then else" << endl;
builder->CreateCondBr(conditionValue, thenBb, elseBb);
builder->SetInsertPoint(thenBb);
Value *thenValue = (*thenStmt).codeGen(context);
builder->CreateBr(mergeBb);
thenBb = builder->GetInsertBlock();
mainFunction->getBasicBlockList().push_back(elseBb);
builder->SetInsertPoint(elseBb);
Value *elseValue = (*elseStmt).codeGen(context);
builder->CreateBr(mergeBb);
elseBb = builder->GetInsertBlock();
mainFunction->getBasicBlockList().push_back(mergeBb);
builder->SetInsertPoint(mergeBb);
return NULL;
}
}
/// compile_set_zero - Emit Code for '0'
void BrainFTraceRecorder::compile_set_zero(BrainFTraceNode *node,
IRBuilder<>& builder) {
Constant *Zero =
ConstantInt::get(IntegerType::getInt8Ty(Header->getContext()), 0);
builder.CreateStore(Zero, DataPtr);
if (node->left != (BrainFTraceNode*)~0ULL)
compile_opcode(node->left, builder);
else {
HeaderPHI->addIncoming(DataPtr, builder.GetInsertBlock());
builder.CreateBr(Header);
}
}
/// compile_right - Emit code for '>'
void BrainFTraceRecorder::compile_right(BrainFTraceNode *node,
IRBuilder<>& builder) {
Value *OldPtr = DataPtr;
DataPtr = builder.CreateConstInBoundsGEP1_32(DataPtr, 1);
if (node->left != (BrainFTraceNode*)~0ULL)
compile_opcode(node->left, builder);
else {
HeaderPHI->addIncoming(DataPtr, builder.GetInsertBlock());
builder.CreateBr(Header);
}
DataPtr = OldPtr;
}
/// compile_get - Emit code for ','
void BrainFTraceRecorder::compile_get(BrainFTraceNode *node,
IRBuilder<>& builder) {
Value *Ret = builder.CreateCall(getchar_func);
Value *Trunc =
builder.CreateTrunc(Ret, IntegerType::get(Ret->getContext(), 8));
builder.CreateStore(Ret, Trunc);
if (node->left != (BrainFTraceNode*)~0ULL)
compile_opcode(node->left, builder);
else {
HeaderPHI->addIncoming(DataPtr, builder.GetInsertBlock());
builder.CreateBr(Header);
}
}
/// compile_put - Emit code for '.'
void BrainFTraceRecorder::compile_put(BrainFTraceNode *node,
IRBuilder<>& builder) {
Value *Loaded = builder.CreateLoad(DataPtr);
Value *Print =
builder.CreateSExt(Loaded, IntegerType::get(Loaded->getContext(), 32));
builder.CreateCall(putchar_func, Print);
if (node->left != (BrainFTraceNode*)~0ULL)
compile_opcode(node->left, builder);
else {
HeaderPHI->addIncoming(DataPtr, builder.GetInsertBlock());
builder.CreateBr(Header);
}
}
void CodeGenContext::generateCode(Block &root)
{
LLVMContext &gC = getGlobalContext(); // globalContext
ArrayRef<Type*> argTypes;
FunctionType *ftype = FunctionType::get(Type::getVoidTy(getGlobalContext()),
argTypes, false);
mainFunction = Function::Create(ftype, GlobalValue::InternalLinkage,
"main", module);
BasicBlock *bblock = BasicBlock::Create(getGlobalContext(),
"entry", mainFunction, 0);
/* header */
// declare void @memset
Type *memset_params_type[] = {
Type::getInt8PtrTy(gC),
Type::getInt32Ty(gC)
};
Function *memset_func = Intrinsic::getDeclaration(module, Intrinsic::memset,
memset_params_type);
// declare i32 @getchar(i32)
getchar_func = cast<Function>(module->
getOrInsertFunction("getchar", IntegerType::getInt32Ty(gC), NULL));
// declare i32 @putchar(i64)
putchar_func = cast<Function>(module->
getOrInsertFunction("putchar", IntegerType::getInt64Ty(gC),
IntegerType::getInt64Ty(gC), NULL));
/* Push a new variable/block context */
pushBlock(bblock);
root.codeGen(*this); /* emit bytecode for the toplevel block */
BasicBlock *endblock = BasicBlock::Create(getGlobalContext(), "end", mainFunction, 0);
IRBuilder<> *builder;
builder = (*this).currentBuilder();
builder->CreateBr(endblock);
builder->SetInsertPoint(endblock);
builder->CreateRetVoid();
popBlock();
std::cout << "Code is generated.\n";
PassManager pm;
pm.add(createPrintModulePass(&outs()));
pm.run(*module);
}
/// compile_minus - Emit code for '-'
void BrainFTraceRecorder::compile_minus(BrainFTraceNode *node,
IRBuilder<>& builder) {
Value *CellValue = builder.CreateLoad(DataPtr);
Constant *One =
ConstantInt::get(IntegerType::getInt8Ty(Header->getContext()), 1);
Value *UpdatedValue = builder.CreateSub(CellValue, One);
builder.CreateStore(UpdatedValue, DataPtr);
if (node->left != (BrainFTraceNode*)~0ULL)
compile_opcode(node->left, builder);
else {
HeaderPHI->addIncoming(DataPtr, builder.GetInsertBlock());
builder.CreateBr(Header);
}
}
void MmixLlvm::Private::emitSetmh(VerticeContext& vctx, IRBuilder<>& builder, MXByte xarg, MXWyde yzarg)
{
Value* result = builder.getInt64((MXOcta)yzarg << 32);
assignRegister(vctx, builder, xarg, result);
builder.CreateBr(vctx.getOCExit());
}
void GNUstep::IMPCacher::SpeculativelyInline(Instruction *call, Function
*function) {
BasicBlock *beforeCallBB = call->getParent();
BasicBlock *callBB = SplitBlock(beforeCallBB, call, Owner);
BasicBlock *inlineBB = BasicBlock::Create(Context, "inline",
callBB->getParent());
BasicBlock::iterator iter = call;
iter++;
BasicBlock *afterCallBB = SplitBlock(iter->getParent(), iter, Owner);
removeTerminator(beforeCallBB);
// Put a branch before the call, testing whether the callee really is the
// function
IRBuilder<> B = IRBuilder<>(beforeCallBB);
Value *callee = isa<CallInst>(call) ? cast<CallInst>(call)->getCalledValue()
: cast<InvokeInst>(call)->getCalledValue();
const FunctionType *FTy = function->getFunctionType();
const FunctionType *calleeTy = cast<FunctionType>(
cast<PointerType>(callee->getType())->getElementType());
if (calleeTy != FTy) {
callee = B.CreateBitCast(callee, function->getType());
}
Value *isInlineValid = B.CreateICmpEQ(callee, function);
B.CreateCondBr(isInlineValid, inlineBB, callBB);
// In the inline BB, add a copy of the call, but this time calling the real
// version.
Instruction *inlineCall = call->clone();
Value *inlineResult= inlineCall;
inlineBB->getInstList().push_back(inlineCall);
B.SetInsertPoint(inlineBB);
if (calleeTy != FTy) {
for (unsigned i=0 ; i<FTy->getNumParams() ; i++) {
LLVMType *callType = calleeTy->getParamType(i);
LLVMType *argType = FTy->getParamType(i);
if (callType != argType) {
inlineCall->setOperand(i, new
BitCastInst(inlineCall->getOperand(i), argType, "", inlineCall));
}
}
if (FTy->getReturnType() != calleeTy->getReturnType()) {
if (FTy->getReturnType() == Type::getVoidTy(Context)) {
inlineResult = Constant::getNullValue(calleeTy->getReturnType());
} else {
inlineResult =
new BitCastInst(inlineCall, calleeTy->getReturnType(), "", inlineBB);
}
}
}
B.CreateBr(afterCallBB);
// Unify the return values
if (call->getType() != Type::getVoidTy(Context)) {
PHINode *phi = CreatePHI(call->getType(), 2, "", afterCallBB->begin());
call->replaceAllUsesWith(phi);
phi->addIncoming(call, callBB);
phi->addIncoming(inlineResult, inlineBB);
}
// Really do the real inlining
InlineFunctionInfo IFI(0, 0);
if (CallInst *c = dyn_cast<CallInst>(inlineCall)) {
c->setCalledFunction(function);
InlineFunction(c, IFI);
} else if (InvokeInst *c = dyn_cast<InvokeInst>(inlineCall)) {
c->setCalledFunction(function);
InlineFunction(c, IFI);
}
}
/// compile_if - Emit code for '['
void BrainFTraceRecorder::compile_if(BrainFTraceNode *node,
IRBuilder<>& builder) {
BasicBlock *ZeroChild = 0;
BasicBlock *NonZeroChild = 0;
BasicBlock *Parent = builder.GetInsertBlock();
LLVMContext &Context = Header->getContext();
// If both directions of the branch go back to the trace-head, just
// jump there directly.
if (node->left == (BrainFTraceNode*)~0ULL &&
node->right == (BrainFTraceNode*)~0ULL) {
HeaderPHI->addIncoming(DataPtr, builder.GetInsertBlock());
builder.CreateBr(Header);
return;
}
// Otherwise, there are two cases to handle for each direction:
// ~0ULL - A branch back to the trace head
// 0 - A branch out of the trace
// * - A branch to a node we haven't compiled yet.
// Go ahead and generate code for both targets.
if (node->left == (BrainFTraceNode*)~0ULL) {
NonZeroChild = Header;
HeaderPHI->addIncoming(DataPtr, Parent);
} else if (node->left == 0) {
NonZeroChild = BasicBlock::Create(Context,
"exit_left_"+utostr(node->pc),
Header->getParent());
builder.SetInsertPoint(NonZeroChild);
// Set the extension leaf, which is a pointer to the leaf of the trace
// tree from which we are side exiting.
ConstantInt *ExtLeaf = ConstantInt::get(int_type, (intptr_t)node);
builder.CreateStore(ExtLeaf, ext_leaf);
ConstantInt *NewPc = ConstantInt::get(int_type, node->pc+1);
Value *BytecodeIndex =
builder.CreateConstInBoundsGEP1_32(bytecode_array, node->pc+1);
Value *Target = builder.CreateLoad(BytecodeIndex);
CallInst *Call =cast<CallInst>(builder.CreateCall2(Target, NewPc, DataPtr));
Call->setTailCall();
builder.CreateRetVoid();
} else {
NonZeroChild = BasicBlock::Create(Context,
utostr(node->left->pc),
Header->getParent());
builder.SetInsertPoint(NonZeroChild);
compile_opcode(node->left, builder);
}
if (node->right == (BrainFTraceNode*)~0ULL) {
ZeroChild = Header;
HeaderPHI->addIncoming(DataPtr, Parent);
} else if (node->right == 0) {
ZeroChild = BasicBlock::Create(Context,
"exit_right_"+utostr(node->pc),
Header->getParent());
builder.SetInsertPoint(ZeroChild);
// Set the extension leaf, which is a pointer to the leaf of the trace
// tree from which we are side exiting.
ConstantInt *ExtLeaf = ConstantInt::get(int_type, (intptr_t)node);
builder.CreateStore(ExtLeaf, ext_leaf);
ConstantInt *NewPc = ConstantInt::get(int_type, JumpMap[node->pc]+1);
Value *BytecodeIndex =
builder.CreateConstInBoundsGEP1_32(bytecode_array, JumpMap[node->pc]+1);
Value *Target = builder.CreateLoad(BytecodeIndex);
CallInst *Call =cast<CallInst>(builder.CreateCall2(Target, NewPc, DataPtr));
Call->setTailCall();
builder.CreateRetVoid();
} else {
ZeroChild = BasicBlock::Create(Context,
utostr(node->right->pc),
Header->getParent());
builder.SetInsertPoint(ZeroChild);
compile_opcode(node->right, builder);
}
// Generate the test and branch to select between the targets.
builder.SetInsertPoint(Parent);
Value *Loaded = builder.CreateLoad(DataPtr);
Value *Cmp = builder.CreateICmpEQ(Loaded,
ConstantInt::get(Loaded->getType(), 0));
builder.CreateCondBr(Cmp, ZeroChild, NonZeroChild);
}
void
code_emitter::emit_stmts (statement_t *stmt, unsigned int slice_flag)
{
for (; stmt != NULL; stmt = stmt->next)
{
if (!must_emit_stmt(stmt, slice_flag))
continue;
switch (stmt->kind)
{
case STMT_NIL :
g_assert(slice_flag == SLICE_IGNORE);
break;
case STMT_ASSIGN :
#ifdef DEBUG_OUTPUT
compiler_print_assign_statement(stmt);
printf("\n");
#endif
if (stmt->v.assign.rhs->kind == RHS_OP
&& stmt->v.assign.rhs->v.op.op->index == OP_OUTPUT_TUPLE)
builder->CreateRet(emit_primary(&stmt->v.assign.rhs->v.op.args[0]));
else
set_value(stmt->v.assign.lhs, emit_rhs(stmt->v.assign.rhs));
break;
case STMT_IF_COND :
{
Value *condition_number = emit_rhs(stmt->v.if_cond.condition);
Value *condition;
map<rhs_t*, Value*> rhs_map;
if (condition_number->getType() == Type::Int32Ty)
condition = builder->CreateICmpNE(condition_number, make_int_const(0));
else if (condition_number->getType() == Type::FloatTy)
condition = builder->CreateFCmpONE(condition_number, make_float_const(0.0));
else
g_assert_not_reached();
BasicBlock *then_bb = BasicBlock::Create("then", current_function);
BasicBlock *else_bb = BasicBlock::Create("else");
BasicBlock *merge_bb = BasicBlock::Create("ifcont");
builder->CreateCondBr(condition, then_bb, else_bb);
builder->SetInsertPoint(then_bb);
emit_stmts(stmt->v.if_cond.consequent, slice_flag);
emit_phi_rhss(stmt->v.if_cond.exit, true, &rhs_map, slice_flag);
builder->CreateBr(merge_bb);
then_bb = builder->GetInsertBlock();
current_function->getBasicBlockList().push_back(else_bb);
builder->SetInsertPoint(else_bb);
emit_stmts(stmt->v.if_cond.alternative, slice_flag);
emit_phi_rhss(stmt->v.if_cond.exit, false, &rhs_map, slice_flag);
builder->CreateBr(merge_bb);
else_bb = builder->GetInsertBlock();
current_function->getBasicBlockList().push_back(merge_bb);
builder->SetInsertPoint(merge_bb);
emit_phis(stmt->v.if_cond.exit, then_bb, else_bb, rhs_map, slice_flag);
}
break;
case STMT_WHILE_LOOP:
{
BasicBlock *start_bb = builder->GetInsertBlock();
BasicBlock *entry_bb = BasicBlock::Create("entry", current_function);
BasicBlock *body_bb = BasicBlock::Create("body");
BasicBlock *exit_bb = BasicBlock::Create("exit");
map<rhs_t*, Value*> rhs_map;
emit_phi_rhss(stmt->v.while_loop.entry, true, &rhs_map, slice_flag);
builder->CreateBr(entry_bb);
builder->SetInsertPoint(entry_bb);
emit_phis(stmt->v.while_loop.entry, start_bb, NULL, rhs_map, slice_flag);
Value *invariant_number = emit_rhs(stmt->v.while_loop.invariant);
Value *invariant;
if (invariant_number->getType() == Type::Int32Ty)
invariant = builder->CreateICmpNE(invariant_number, make_int_const(0));
else if (invariant_number->getType() == Type::FloatTy)
invariant = builder->CreateFCmpONE(invariant_number, make_float_const(0.0));
else
g_assert_not_reached();
builder->CreateCondBr(invariant, body_bb, exit_bb);
current_function->getBasicBlockList().push_back(body_bb);
builder->SetInsertPoint(body_bb);
emit_stmts(stmt->v.while_loop.body, slice_flag);
body_bb = builder->GetInsertBlock();
emit_phi_rhss(stmt->v.while_loop.entry, false, &rhs_map, slice_flag);
emit_phis(stmt->v.while_loop.entry, NULL, body_bb, rhs_map, slice_flag);
builder->CreateBr(entry_bb);
current_function->getBasicBlockList().push_back(exit_bb);
builder->SetInsertPoint(exit_bb);
}
break;
default:
g_assert_not_reached();
break;
}
}
}
JITFunction*
CompilePipeline(Pipeline *pipeline, Thread *thread) {
size_t i = 0;
size_t size = 0;
std::unique_ptr<Module> owner = make_unique<Module>("PipelineFunction", thread->context);
Module *module = owner.get();
std::string fname = std::string("PipelineFunction") + std::to_string(thread->functions++);
size_t input_count = pipeline->inputData->objects.size();
size_t output_count = pipeline->outputData->objects.size();
size_t function_arg_count = 6;
size_t arg_count = input_count + output_count + (function_arg_count - 2);
size_t start_addr = input_count + output_count;
size_t end_addr = start_addr + 1;
size_t result_sizes_addr = end_addr + 1;
size_t thread_nr_addr = result_sizes_addr + 1;
IRBuilder<> *builder = &thread->builder;
auto passmanager = CreatePassManager(module, thread->jit.get());
module->setDataLayout(thread->jit->getTargetMachine().createDataLayout());
Type *int8_tpe = Type::getInt8Ty(thread->context);
Type *int8ptr_tpe = PointerType::get(int8_tpe, 0);
Type *int8ptrptr_tpe = PointerType::get(int8ptr_tpe, 0);
Type *int64_tpe = Type::getInt64Ty(thread->context);
Type *int64ptr_tpe = PointerType::get(int64_tpe, 0);
JITInformation info;
// arguments of the function
// the arguments are (void **result, void** inputs, size_t start, size_t end);
// note that we don't actually use void**, we use int8**, because LLVM does not support void pointers
std::vector<Type*> arguments(function_arg_count);
i = 0;
arguments[i++] = int8ptrptr_tpe; // void** results
arguments[i++] = int8ptrptr_tpe; // void** inputs
arguments[i++] = int64_tpe; // size_t start
arguments[i++] = int64_tpe; // size_t end
arguments[i++] = int64ptr_tpe; // size_t* result_sizes
arguments[i++] = int64_tpe; // size_t thread_nr
assert(i == function_arg_count);
/*for(auto inputs = pipeline->inputData->objects.begin(); inputs != pipeline->inputData->objects.end(); inputs++, i++) {
arguments[i] = PointerType::get(getLLVMType(thread->context, inputs->type), 0);
}
for(auto outputs = pipeline->outputData->objects.begin(); outputs != pipeline->outputData->objects.end(); outputs++, i++) {
arguments[i] = PointerType::get(getLLVMType(thread->context, outputs->type), 0);
}*/
// create the LLVM function
FunctionType *prototype = FunctionType::get(int64_tpe, arguments, false);
Function *function = Function::Create(prototype, GlobalValue::ExternalLinkage, fname, module);
function->setCallingConv(CallingConv::C);
// create the basic blocks
BasicBlock *loop_entry = BasicBlock::Create(thread->context, "entry", function, 0);
BasicBlock *loop_cond = BasicBlock::Create(thread->context, "for.cond", function, 0);
BasicBlock *loop_body = BasicBlock::Create(thread->context, "for.body", function, 0);
BasicBlock *loop_inc = BasicBlock::Create(thread->context, "for.inc", function, 0);
BasicBlock *loop_end = BasicBlock::Create(thread->context, "for.end", function, 0);
info.builder = &thread->builder;
info.context = &thread->context;
info.function = function;
info.loop_entry = loop_entry;
info.loop_cond = loop_cond;
info.loop_body = loop_body;
info.loop_inc = loop_inc;
info.loop_end = loop_end;
info.current = loop_body;
#ifndef _NOTDEBUG
// argument names (for debug purposes only)
std::vector<std::string> argument_names(arg_count);
i = 0;
for(auto inputs = pipeline->inputData->objects.begin(); inputs != pipeline->inputData->objects.end(); inputs++, i++) {
argument_names[i] = std::string("inputs") + std::to_string(i);
}
for(auto outputs = pipeline->outputData->objects.begin(); outputs != pipeline->outputData->objects.end(); outputs++, i++) {
argument_names[i] = std::string("outputs") + std::to_string(i - input_count);
}
argument_names[i++] = "start";
argument_names[i++] = "end";
argument_names[i++] = "result_sizes";
argument_names[i++] = "thread_nr";
#endif
std::vector<AllocaInst*> argument_addresses(arg_count);
builder->SetInsertPoint(loop_entry);
{
// allocate space for the arguments
auto args = function->arg_begin();
i = 0;
for(auto outputs = pipeline->outputData->objects.begin(); outputs != pipeline->outputData->objects.end(); outputs++, i++) {
Type *column_type = PointerType::get(getLLVMType(thread->context, outputs->source->type), 0);
Value *voidptrptr = builder->CreateGEP(int8ptr_tpe, &*args, ConstantInt::get(int64_tpe, i, true));
Value *voidptr = builder->CreateLoad(voidptrptr, "voidptr");
Value *columnptr = builder->CreatePointerCast(voidptr, column_type);
argument_addresses[i] = builder->CreateAlloca(column_type, nullptr, argument_names[i]);
builder->CreateStore(columnptr, argument_addresses[i]);
outputs->alloca_address = (void*) argument_addresses[i];
if (size == 0 || size == 1) {
assert(outputs->source->size >= 0);
size = outputs->source->size;
}
assert(size == outputs->source->size || outputs->source->size == 1);
}
args++;
for(auto inputs = pipeline->inputData->objects.begin(); inputs != pipeline->inputData->objects.end(); inputs++, i++) {
Type *column_type = PointerType::get(getLLVMType(thread->context, inputs->source->type), 0);
Value *voidptrptr = builder->CreateGEP(int8ptr_tpe, &*args, ConstantInt::get(int64_tpe, i - output_count, true));
Value *voidptr = builder->CreateLoad(voidptrptr, "voidptr");
Value *columnptr = builder->CreatePointerCast(voidptr, column_type);
argument_addresses[i] = builder->CreateAlloca(column_type, nullptr, argument_names[i]);
builder->CreateStore(columnptr, argument_addresses[i]);
inputs->alloca_address = (void*) argument_addresses[i];
if (size == 0 || size == 1) {
assert(inputs->source->size >= 0);
size = inputs->source->size;
}
assert(size == inputs->source->size || inputs->source->size == 1);
}
args++;
argument_addresses[i] = builder->CreateAlloca(arguments[2], nullptr, argument_names[i]);
builder->CreateStore(&*args, argument_addresses[i]);
args++; i++;
argument_addresses[i] = builder->CreateAlloca(arguments[3], nullptr, argument_names[i]);
builder->CreateStore(&*args, argument_addresses[i]);
args++; i++;
argument_addresses[i] = builder->CreateAlloca(arguments[4], nullptr, argument_names[i]);
builder->CreateStore(&*args, argument_addresses[i]);
args++; i++;
argument_addresses[i] = builder->CreateAlloca(arguments[5], nullptr, argument_names[i]);
builder->CreateStore(&*args, argument_addresses[i]);
args++; i++;
assert(args == function->arg_end());
assert(i == arg_count);
info.index_addr = argument_addresses[start_addr];
info.thread_addr = argument_addresses[thread_nr_addr];
PerformInitialization(info, pipeline->operation);
builder->CreateBr(loop_cond);
}
// for loop condition: index < end
builder->SetInsertPoint(loop_cond);
{
LoadInst *index = builder->CreateLoad(argument_addresses[start_addr], "index");
LoadInst *end = builder->CreateLoad(argument_addresses[end_addr], "end");
Value *condition = builder->CreateICmpSLT(index, end, "index < end");
builder->CreateCondBr(condition, loop_body, loop_end);
}
// loop body: perform the computation
builder->SetInsertPoint(loop_body);
{
LoadInst *index = builder->CreateLoad(argument_addresses[start_addr], "index");
info.index = index;
info.index_addr = argument_addresses[start_addr];
// perform the computation over the given index
// we don't use the return value because the final assignment has already taken place
Value *v = PerformOperation(info, thread->builder, thread->context, pipeline->operation, pipeline->inputData, pipeline->outputData);
if (v == NULL) {
// failed to perform operation
printf("Failed to compile pipeline %s\n", pipeline->name);
return NULL;
}
builder->CreateBr(loop_inc);
}
// loop increment: index++
builder->SetInsertPoint(loop_inc);
{
LoadInst *index = builder->CreateLoad(argument_addresses[start_addr], "index");
Value *incremented_index = builder->CreateAdd(index, ConstantInt::get(int64_tpe, 1, true), "index++");
builder->CreateStore(incremented_index, argument_addresses[start_addr]);
builder->CreateBr(loop_cond);
}
// loop end: return; (nothing happens here because we have no return value)
builder->SetInsertPoint(loop_end);
{
// return the output size of each of the columns
int i = 0;
Value *result_sizes = builder->CreateLoad(argument_addresses[result_sizes_addr], "result_sizes[]");
for(auto it = pipeline->outputData->objects.begin(); it != pipeline->outputData->objects.end(); it++) {
Value* output_count;
if (it->index_addr) {
output_count = builder->CreateLoad((Value*) it->index_addr, "count");
} else {
output_count = ConstantInt::get(int64_tpe, 1, true);
}
Value *output_addr = builder->CreateGEP(int64_tpe, result_sizes, ConstantInt::get(int64_tpe, i, true));
builder->CreateStore(output_count, output_addr);
i++;
}
builder->CreateRet(ConstantInt::get(int64_tpe, 0, true));
}
#ifndef _NOTDEBUG
verifyFunction(*function);
verifyModule(*module);
#endif
//printf("LLVM for pipeline %s\n", pipeline->name);
module->dump();
passmanager->run(*function);
// dump generated LLVM code
//module->dump();
auto handle = thread->jit->addModule(std::move(owner));
jit_function compiled_function = (jit_function) thread->jit->findSymbol(fname).getAddress();
if (!compiled_function) {
printf("Error creating function.\n");
return NULL;
}
JITFunction *jf = CreateJITFunction(thread, pipeline);
jf->size = size;
jf->function = compiled_function;
jf->jit = thread->jit.get();
jf->handle = handle;
assert(jf->function);
return jf;
}