148 source/Codegen/BinaryOpCodegen.cpp
View file

Large diffs are not rendered by default.

84 source/Codegen/CodegenUtils.cpp
View file
@@ -29,11 +29,11 @@ namespace Codegen
{
void doCodegen(std::string filename, Root* root, CodegenInstance* cgi)
{
cgi->mainModule = new llvm::Module(Parser::getModuleName(filename), llvm::getGlobalContext());
cgi->module = new llvm::Module(Parser::getModuleName(filename), llvm::getGlobalContext());
cgi->rootNode = root;

std::string err;
cgi->execEngine = llvm::EngineBuilder(std::unique_ptr<llvm::Module>(cgi->mainModule))
cgi->execEngine = llvm::EngineBuilder(std::unique_ptr<llvm::Module>(cgi->module))
.setErrorStr(&err)
.setMCJITMemoryManager(llvm::make_unique<llvm::SectionMemoryManager>())
.create();
@@ -44,7 +44,7 @@ namespace Codegen
exit(1);
}

llvm::FunctionPassManager functionPassManager = llvm::FunctionPassManager(cgi->mainModule);
llvm::FunctionPassManager functionPassManager = llvm::FunctionPassManager(cgi->module);

if(Compiler::getOptimisationLevel() > 0)
{
@@ -109,11 +109,11 @@ namespace Codegen
iceAssert(func);

// add to the func table
auto lf = cgi->mainModule->getFunction(func->getName());
auto lf = cgi->module->getFunction(func->getName());
if(!lf)
{
cgi->mainModule->getOrInsertFunction(func->getName(), func->getFunctionType());
lf = cgi->mainModule->getFunction(func->getName());
cgi->module->getOrInsertFunction(func->getName(), func->getFunctionType());
lf = cgi->module->getFunction(func->getName());
}

llvm::Function* f = llvm::cast<llvm::Function>(lf);
@@ -158,7 +158,7 @@ namespace Codegen

llvm::raw_fd_ostream rso(oname.c_str(), e, of);

llvm::WriteBitcodeToFile(cgi->mainModule, rso);
llvm::WriteBitcodeToFile(cgi->module, rso);
rso.close();
}

@@ -725,17 +725,17 @@ namespace Codegen
// // var data: Int8*
// // var allocated: Uint64

// llvm::Value* stringPtr = this->mainBuilder.CreateStructGEP(alloca, 0);
// llvm::Value* allocdPtr = this->mainBuilder.CreateStructGEP(alloca, 1);
// llvm::Value* stringPtr = this->builder.CreateStructGEP(alloca, 0);
// llvm::Value* allocdPtr = this->builder.CreateStructGEP(alloca, 1);

// llvm::Value* newstr = this->mainBuilder.CreateAlloca(int8ptr->getType(), );
// llvm::Value* newstr = this->builder.CreateAlloca(int8ptr->getType(), );

// llvm::Value* stringVal = this->mainBuilder.CreateGlobalStringPtr(this->str);
// llvm::Value* stringVal = this->builder.CreateGlobalStringPtr(this->str);

// this->mainBuilder.CreateStore(stringVal, stringPtr);
// this->mainBuilder.CreateStore(llvm::ConstantInt::get(llvm::IntegerType::getInt64Ty(cgi->getContext()), 0), allocdPtr);
// this->builder.CreateStore(stringVal, stringPtr);
// this->builder.CreateStore(llvm::ConstantInt::get(llvm::IntegerType::getInt64Ty(cgi->getContext()), 0), allocdPtr);

// llvm::Value* val = this->mainBuilder.CreateLoad(alloca);
// llvm::Value* val = this->builder.CreateLoad(alloca);
// return Result_t(val, alloca);
return Result_t(0, 0);
}
@@ -841,22 +841,22 @@ namespace Codegen
}

// get the function with the same name in the current module
opov = this->mainModule->getFunction(opov->getName());
opov = this->module->getFunction(opov->getName());
iceAssert(opov);

// try the assign op.
if(op == ArithmeticOp::Assign || op == ArithmeticOp::PlusEquals || op == ArithmeticOp::MinusEquals
|| op == ArithmeticOp::MultiplyEquals || op == ArithmeticOp::DivideEquals)
{
// check args.
llvm::Value* ret = mainBuilder.CreateCall2(opov, self, val);
llvm::Value* ret = builder.CreateCall2(opov, self, val);
return Result_t(ret, self);
}
else if(op == ArithmeticOp::CmpEq || op == ArithmeticOp::Add || op == ArithmeticOp::Subtract || op == ArithmeticOp::Multiply
|| op == ArithmeticOp::Divide)
{
// check that both types work
return Result_t(mainBuilder.CreateCall2(opov, self, val), 0);
return Result_t(builder.CreateCall2(opov, self, val), 0);
}

if(fail) GenError::noOpOverload(this, user, str->name, op);
@@ -915,29 +915,29 @@ namespace Codegen
if(!initf)
GenError::invalidInitialiser(this, user, str, vals);

return this->mainModule->getFunction(initf->getName());
return this->module->getFunction(initf->getName());
}


Result_t CodegenInstance::assignValueToAny(llvm::Value* lhsPtr, llvm::Value* rhs, llvm::Value* rhsPtr)
{
llvm::Value* typegep = this->mainBuilder.CreateStructGEP(lhsPtr, 0); // Any
typegep = this->mainBuilder.CreateStructGEP(typegep, 0, "type"); // Type
llvm::Value* typegep = this->builder.CreateStructGEP(lhsPtr, 0); // Any
typegep = this->builder.CreateStructGEP(typegep, 0, "type"); // Type

size_t index = TypeInfo::getIndexForType(this, rhs->getType());
iceAssert(index > 0);

llvm::Value* constint = llvm::ConstantInt::get(typegep->getType()->getPointerElementType(), index);
this->mainBuilder.CreateStore(constint, typegep);
this->builder.CreateStore(constint, typegep);



llvm::Value* valgep = this->mainBuilder.CreateStructGEP(lhsPtr, 1, "value");
llvm::Value* valgep = this->builder.CreateStructGEP(lhsPtr, 1, "value");
if(rhsPtr)
{
// printf("rhsPtr, %s\n", this->getReadableType(valgep).c_str());
llvm::Value* casted = this->mainBuilder.CreatePointerCast(rhsPtr, valgep->getType()->getPointerElementType(), "pcast");
this->mainBuilder.CreateStore(casted, valgep);
llvm::Value* casted = this->builder.CreatePointerCast(rhsPtr, valgep->getType()->getPointerElementType(), "pcast");
this->builder.CreateStore(casted, valgep);
}
else
{
@@ -946,43 +946,43 @@ namespace Codegen

if(rhs->getType()->isIntegerTy())
{
llvm::Value* casted = this->mainBuilder.CreateIntToPtr(rhs, targetType);
this->mainBuilder.CreateStore(casted, valgep);
llvm::Value* casted = this->builder.CreateIntToPtr(rhs, targetType);
this->builder.CreateStore(casted, valgep);
}
else
{
llvm::Value* casted = this->mainBuilder.CreateBitCast(rhs, targetType);
casted = this->mainBuilder.CreateIntToPtr(casted, valgep->getType()->getPointerElementType());
this->mainBuilder.CreateStore(casted, valgep);
llvm::Value* casted = this->builder.CreateBitCast(rhs, targetType);
casted = this->builder.CreateIntToPtr(casted, valgep->getType()->getPointerElementType());
this->builder.CreateStore(casted, valgep);
}
}

return Result_t(this->mainBuilder.CreateLoad(lhsPtr), lhsPtr);
return Result_t(this->builder.CreateLoad(lhsPtr), lhsPtr);
}


Result_t CodegenInstance::extractValueFromAny(llvm::Type* type, llvm::Value* ptr)
{
llvm::Value* valgep = this->mainBuilder.CreateStructGEP(ptr, 1);
llvm::Value* loadedval = this->mainBuilder.CreateLoad(valgep);
llvm::Value* valgep = this->builder.CreateStructGEP(ptr, 1);
llvm::Value* loadedval = this->builder.CreateLoad(valgep);

if(type->isStructTy())
{
// use pointer stuff
llvm::Value* valptr = this->mainBuilder.CreatePointerCast(loadedval, type->getPointerTo());
llvm::Value* loaded = this->mainBuilder.CreateLoad(valptr);
llvm::Value* valptr = this->builder.CreatePointerCast(loadedval, type->getPointerTo());
llvm::Value* loaded = this->builder.CreateLoad(valptr);

return Result_t(loaded, valptr);
}
else
{
// the pointer is actually a literal
llvm::Type* targetType = type->isIntegerTy() ? type : llvm::IntegerType::getInt64Ty(this->getContext());
llvm::Value* val = this->mainBuilder.CreatePtrToInt(loadedval, targetType);
llvm::Value* val = this->builder.CreatePtrToInt(loadedval, targetType);

if(val->getType() != type)
{
val = this->mainBuilder.CreateBitCast(val, type);
val = this->builder.CreateBitCast(val, type);
}

return Result_t(val, 0);
@@ -1015,23 +1015,23 @@ namespace Codegen
llvm::Value* intval = llvm::Constant::getIntegerValue(llvm::IntegerType::getIntNTy(this->getContext(), ptrWidth), apint);

if(rhs->getType()->getIntegerBitWidth() != ptrWidth)
rhs = this->mainBuilder.CreateIntCast(rhs, intval->getType(), false);
rhs = this->builder.CreateIntCast(rhs, intval->getType(), false);


// this is the properly adjusted thing
llvm::Value* newrhs = this->mainBuilder.CreateMul(rhs, intval);
llvm::Value* newrhs = this->builder.CreateMul(rhs, intval);

// convert the lhs pointer to an int value, so we can add/sub on it
llvm::Value* ptrval = this->mainBuilder.CreatePtrToInt(lhs, newrhs->getType());
llvm::Value* ptrval = this->builder.CreatePtrToInt(lhs, newrhs->getType());

// create the add/sub
llvm::Value* res = this->mainBuilder.CreateBinOp(lop, ptrval, newrhs);
llvm::Value* res = this->builder.CreateBinOp(lop, ptrval, newrhs);

// turn the int back into a pointer, so we can store it back into the var.
llvm::Value* tempRes = lhsPtr ? lhsPtr : this->allocateInstanceInBlock(lhs->getType());

llvm::Value* properres = this->mainBuilder.CreateIntToPtr(res, lhs->getType());
this->mainBuilder.CreateStore(properres, tempRes);
llvm::Value* properres = this->builder.CreateIntToPtr(res, lhs->getType());
this->builder.CreateStore(properres, tempRes);
return Result_t(properres, tempRes);
}

6 source/Codegen/Functions/FuncCallCodegen.cpp
View file
@@ -23,8 +23,8 @@ static Result_t callConstructor(CodegenInstance* cgi, TypePair_t* tp, FuncCall*

llvm::Function* initfunc = cgi->getStructInitialiser(fc, tp, args);

cgi->mainBuilder.CreateCall(initfunc, args);
llvm::Value* val = cgi->mainBuilder.CreateLoad(ai);
cgi->builder.CreateCall(initfunc, args);
llvm::Value* val = cgi->builder.CreateLoad(ai);

return Result_t(val, ai);
}
@@ -126,7 +126,7 @@ Result_t FuncCall::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Valu
}
}

return Result_t(cgi->mainBuilder.CreateCall(target, args), 0);
return Result_t(cgi->builder.CreateCall(target, args), 0);
}


14 source/Codegen/Functions/FuncCodegen.cpp
View file
@@ -43,7 +43,7 @@ Result_t Func::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value* r
// because the main code generator is two-pass, we expect all function declarations to have been generated
// so just fetch it.

llvm::Function* func = cgi->mainModule->getFunction(this->decl->mangledName);
llvm::Function* func = cgi->module->getFunction(this->decl->mangledName);
iceAssert(func && "Function was not declared before being generated!");


@@ -63,10 +63,10 @@ Result_t Func::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value* r
// to support declaring functions inside functions, we need to remember
// the previous insert point, or all further codegen will happen inside this function
// and fuck shit up big time
llvm::BasicBlock* prevBlock = cgi->mainBuilder.GetInsertBlock();
llvm::BasicBlock* prevBlock = cgi->builder.GetInsertBlock();

llvm::BasicBlock* block = llvm::BasicBlock::Create(cgi->getContext(), this->decl->name + "_entry", func);
cgi->mainBuilder.SetInsertPoint(block);
cgi->builder.SetInsertPoint(block);


// unfortunately, because we have to clear the symtab above, we need to add the param vars here
@@ -78,7 +78,7 @@ Result_t Func::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value* r
it->setName(this->decl->params[i]->name);

llvm::AllocaInst* ai = cgi->allocateInstanceInBlock(this->decl->params[i]);
cgi->mainBuilder.CreateStore(it, ai);
cgi->builder.CreateStore(it, ai);

cgi->addSymbol(this->decl->params[i]->name, ai, this->decl->params[i]);
}
@@ -135,10 +135,10 @@ Result_t Func::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value* r
cgi->verifyAllPathsReturn(this, nullptr, true);

if(doRetVoid)
cgi->mainBuilder.CreateRetVoid();
cgi->builder.CreateRetVoid();

else if(isImplicitReturn)
cgi->mainBuilder.CreateRet(lastval.result.first);
cgi->builder.CreateRet(lastval.result.first);


llvm::verifyFunction(*func, &llvm::errs());
@@ -148,7 +148,7 @@ Result_t Func::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value* r
cgi->popScope();

if(prevBlock)
cgi->mainBuilder.SetInsertPoint(prevBlock);
cgi->builder.SetInsertPoint(prevBlock);

cgi->clearCurrentFunctionScope();
return Result_t(func, 0);
4 source/Codegen/Functions/FuncDeclCodegen.cpp
View file
@@ -158,7 +158,7 @@ Result_t FuncDecl::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Valu
{
GenError::duplicateSymbol(cgi, this, this->name + " (symbol previously declared as a type)", SymbolType::Generic);
}
else if(cgi->isDuplicateFuncDecl(this->mangledName) /*cgi->mainModule->getFunction(this->mangledName)*/)
else if(cgi->isDuplicateFuncDecl(this->mangledName) /*cgi->module->getFunction(this->mangledName)*/)
{
if(!this->isFFI)
{
@@ -167,7 +167,7 @@ Result_t FuncDecl::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Valu
}
else
{
func = llvm::Function::Create(ft, linkageType, this->mangledName, cgi->mainModule);
func = llvm::Function::Create(ft, linkageType, this->mangledName, cgi->module);
cgi->addFunctionToScope(this->mangledName, FuncPair_t(func, this));
}

10 source/Codegen/Functions/GlobalConstructors.cpp
View file
@@ -14,7 +14,7 @@ namespace Codegen
{
void CodegenInstance::addGlobalConstructor(std::string name, llvm::Function* constructor)
{
llvm::GlobalVariable* gv = this->mainModule->getGlobalVariable(name);
llvm::GlobalVariable* gv = this->module->getGlobalVariable(name);
iceAssert(gv);

this->globalConstructors[gv] = constructor;
@@ -24,17 +24,17 @@ namespace Codegen
{
// generate initialiser
llvm::FunctionType* ft = llvm::FunctionType::get(llvm::Type::getVoidTy(llvm::getGlobalContext()), false);
llvm::Function* defaultInitFunc = llvm::Function::Create(ft, llvm::GlobalValue::ExternalLinkage, "__global_constructor__" + this->mainModule->getModuleIdentifier(), this->mainModule);
llvm::Function* defaultInitFunc = llvm::Function::Create(ft, llvm::GlobalValue::ExternalLinkage, "__global_constructor__" + this->module->getModuleIdentifier(), this->module);

llvm::BasicBlock* iblock = llvm::BasicBlock::Create(llvm::getGlobalContext(), "initialiser", defaultInitFunc);
this->mainBuilder.SetInsertPoint(iblock);
this->builder.SetInsertPoint(iblock);

for(auto pair : this->globalConstructors)
{
this->mainBuilder.CreateCall(pair.second, pair.first);
this->builder.CreateCall(pair.second, pair.first);
}

this->mainBuilder.CreateRetVoid();
this->builder.CreateRetVoid();
this->rootNode->globalConstructorTrampoline = defaultInitFunc;
}
}
34 source/Codegen/IfCodegen.cpp
View file
@@ -24,11 +24,11 @@ static void codeGenRecursiveIf(CodegenInstance* cgi, llvm::Function* func, std::


llvm::Type* apprType = cgi->getLlvmType(pairs.front().first);
cond = cgi->mainBuilder.CreateICmpNE(cond, llvm::Constant::getNullValue(apprType), "ifCond");
cond = cgi->builder.CreateICmpNE(cond, llvm::Constant::getNullValue(apprType), "ifCond");


cgi->mainBuilder.CreateCondBr(cond, t, f);
cgi->mainBuilder.SetInsertPoint(t);
cgi->builder.CreateCondBr(cond, t, f);
cgi->builder.SetInsertPoint(t);

Result_t blockResult(0, 0);
llvm::Value* val = nullptr;
@@ -44,12 +44,12 @@ static void codeGenRecursiveIf(CodegenInstance* cgi, llvm::Function* func, std::

// check if the last expr of the block is a return
if(blockResult.type != ResultType::BreakCodegen)
cgi->mainBuilder.CreateBr(merge), *didCreateMerge = true;
cgi->builder.CreateBr(merge), *didCreateMerge = true;


// now the false case...
// set the insert point to the false case, then go again.
cgi->mainBuilder.SetInsertPoint(f);
cgi->builder.SetInsertPoint(f);

// recursively call ourselves
pairs.pop_front();
@@ -64,27 +64,27 @@ Result_t If::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value* rhs
iceAssert(this->cases.size() > 0);
llvm::Value* firstCond = this->cases[0].first->codegen(cgi).result.first;
llvm::Type* apprType = cgi->getLlvmType(this->cases[0].first);
firstCond = cgi->mainBuilder.CreateICmpNE(firstCond, llvm::Constant::getNullValue(apprType), "ifCond");
firstCond = cgi->builder.CreateICmpNE(firstCond, llvm::Constant::getNullValue(apprType), "ifCond");



llvm::Function* func = cgi->mainBuilder.GetInsertBlock()->getParent();
llvm::Function* func = cgi->builder.GetInsertBlock()->getParent();
iceAssert(func);

llvm::BasicBlock* trueb = llvm::BasicBlock::Create(cgi->getContext(), "trueCase", func);
llvm::BasicBlock* falseb = llvm::BasicBlock::Create(cgi->getContext(), "falseCase", func);
llvm::BasicBlock* merge = llvm::BasicBlock::Create(cgi->getContext(), "merge", func);

// create the first conditional
cgi->mainBuilder.CreateCondBr(firstCond, trueb, falseb);
cgi->builder.CreateCondBr(firstCond, trueb, falseb);


bool didMerge = false;

// emit code for the first block
llvm::Value* truev = nullptr;
{
cgi->mainBuilder.SetInsertPoint(trueb);
cgi->builder.SetInsertPoint(trueb);

// push a new symtab
cgi->pushScope();
@@ -95,7 +95,7 @@ Result_t If::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value* rhs
cgi->popScope();

if(cresult.type != ResultType::BreakCodegen)
cgi->mainBuilder.CreateBr(merge), didMerge = true;
cgi->builder.CreateBr(merge), didMerge = true;
}


@@ -104,22 +104,22 @@ Result_t If::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value* rhs
// to support if-elseif-elseif-elseif-...-else, we need to essentially compound/cascade conditionals in the 'else' block
// of the if statement.

cgi->mainBuilder.SetInsertPoint(falseb);
cgi->builder.SetInsertPoint(falseb);

auto c1 = this->cases.front();
this->cases.pop_front();

llvm::BasicBlock* curblk = cgi->mainBuilder.GetInsertBlock();
cgi->mainBuilder.SetInsertPoint(merge);
llvm::BasicBlock* curblk = cgi->builder.GetInsertBlock();
cgi->builder.SetInsertPoint(merge);

// llvm::PHINode* phi = mainBuilder.CreatePHI(llvm::Type::getVoidTy(getContext()), this->cases.size() + (this->final ? 1 : 0));
// llvm::PHINode* phi = builder.CreatePHI(llvm::Type::getVoidTy(getContext()), this->cases.size() + (this->final ? 1 : 0));

llvm::PHINode* phi = nullptr;

if(phi)
phi->addIncoming(truev, trueb);

cgi->mainBuilder.SetInsertPoint(curblk);
cgi->builder.SetInsertPoint(curblk);
codeGenRecursiveIf(cgi, func, std::deque<std::pair<Expr*, BracedBlock*>>(this->cases), merge, phi, &didMerge);

// func->getBasicBlockList().push_back(falseb);
@@ -140,12 +140,12 @@ Result_t If::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value* rhs


if(!this->final || elseResult.type != ResultType::BreakCodegen)
cgi->mainBuilder.CreateBr(merge), didMerge = true;
cgi->builder.CreateBr(merge), didMerge = true;


if(didMerge)
{
cgi->mainBuilder.SetInsertPoint(merge);
cgi->builder.SetInsertPoint(merge);
}
else
{
18 source/Codegen/LiteralCodegen.cpp
View file
@@ -45,15 +45,15 @@ Result_t StringLiteral::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm:
// var allocated: Uint64


llvm::Value* stringPtr = cgi->mainBuilder.CreateStructGEP(alloca, 0);
llvm::Value* allocdPtr = cgi->mainBuilder.CreateStructGEP(alloca, 1);
llvm::Value* stringPtr = cgi->builder.CreateStructGEP(alloca, 0);
llvm::Value* allocdPtr = cgi->builder.CreateStructGEP(alloca, 1);

llvm::Value* stringVal = cgi->mainBuilder.CreateGlobalStringPtr(this->str);
llvm::Value* stringVal = cgi->builder.CreateGlobalStringPtr(this->str);

cgi->mainBuilder.CreateStore(stringVal, stringPtr);
cgi->mainBuilder.CreateStore(llvm::ConstantInt::get(llvm::IntegerType::getInt64Ty(cgi->getContext()), 0), allocdPtr);
cgi->builder.CreateStore(stringVal, stringPtr);
cgi->builder.CreateStore(llvm::ConstantInt::get(llvm::IntegerType::getInt64Ty(cgi->getContext()), 0), allocdPtr);

llvm::Value* val = cgi->mainBuilder.CreateLoad(alloca);
llvm::Value* val = cgi->builder.CreateLoad(alloca);
return Result_t(val, alloca);
}
else
@@ -62,7 +62,7 @@ Result_t StringLiteral::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm:
warn(this, "String type not available, using Int8* for string literal");

// good old Int8*
llvm::Value* stringVal = cgi->mainBuilder.CreateGlobalStringPtr(this->str);
llvm::Value* stringVal = cgi->builder.CreateGlobalStringPtr(this->str);
return Result_t(stringVal, 0);
}
}
@@ -108,10 +108,10 @@ Result_t ArrayLiteral::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::
}

llvm::ArrayType* atype = llvm::ArrayType::get(tp, this->values.size());
llvm::Value* alloc = cgi->mainBuilder.CreateAlloca(atype);
llvm::Value* alloc = cgi->builder.CreateAlloca(atype);
llvm::Value* val = llvm::ConstantArray::get(atype, vals);

cgi->mainBuilder.CreateStore(val, alloc);
cgi->builder.CreateStore(val, alloc);
return Result_t(val, alloc);
}

28 source/Codegen/LoopCodegen.cpp
View file
@@ -23,7 +23,7 @@ Result_t Break::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*
iceAssert(cs->second.second);

// for break, we go to the ending block
cgi->mainBuilder.CreateBr(cs->second.second);
cgi->builder.CreateBr(cs->second.second);
return Result_t(0, 0, ResultType::BreakCodegen);
}

@@ -40,7 +40,7 @@ Result_t Continue::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Valu
iceAssert(cs->second.second);

// for continue, we go to the beginning (loop) block
cgi->mainBuilder.CreateBr(cs->second.first);
cgi->builder.CreateBr(cs->second.first);
return Result_t(0, 0, ResultType::BreakCodegen);
}

@@ -51,19 +51,19 @@ Result_t Return::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*
auto res = this->val->codegen(cgi).result;
llvm::Value* left = res.first;

auto f = cgi->mainBuilder.GetInsertBlock()->getParent();
auto f = cgi->builder.GetInsertBlock()->getParent();
iceAssert(f);

if(left->getType()->isIntegerTy() && f->getReturnType()->isIntegerTy())
left = cgi->mainBuilder.CreateIntCast(left, f->getReturnType(), false);
left = cgi->builder.CreateIntCast(left, f->getReturnType(), false);

this->actualReturnValue = left;

return Result_t(cgi->mainBuilder.CreateRet(left), res.second, ResultType::BreakCodegen);
return Result_t(cgi->builder.CreateRet(left), res.second, ResultType::BreakCodegen);
}
else
{
return Result_t(cgi->mainBuilder.CreateRetVoid(), 0, ResultType::BreakCodegen);
return Result_t(cgi->builder.CreateRetVoid(), 0, ResultType::BreakCodegen);
}
}

@@ -75,29 +75,29 @@ Result_t DeferredExpr::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::

Result_t WhileLoop::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value* rhs)
{
llvm::Function* parentFunc = cgi->mainBuilder.GetInsertBlock()->getParent();
llvm::Function* parentFunc = cgi->builder.GetInsertBlock()->getParent();
iceAssert(parentFunc);

llvm::BasicBlock* setupBlock = llvm::BasicBlock::Create(cgi->getContext(), "loopSetup", parentFunc);
llvm::BasicBlock* loopBody = llvm::BasicBlock::Create(cgi->getContext(), "loopBody", parentFunc);
llvm::BasicBlock* loopEnd = llvm::BasicBlock::Create(cgi->getContext(), "loopEnd", parentFunc);

cgi->mainBuilder.CreateBr(setupBlock);
cgi->mainBuilder.SetInsertPoint(setupBlock);
cgi->builder.CreateBr(setupBlock);
cgi->builder.SetInsertPoint(setupBlock);

llvm::Value* condOutside = this->cond->codegen(cgi).result.first;

// branch to the body, since llvm doesn't allow unforced fallthroughs
// if we're a do-while, don't check the condition the first time
// else we should
if(this->isDoWhileVariant)
cgi->mainBuilder.CreateBr(loopBody);
cgi->builder.CreateBr(loopBody);

else
cgi->mainBuilder.CreateCondBr(condOutside, loopBody, loopEnd);
cgi->builder.CreateCondBr(condOutside, loopBody, loopEnd);


cgi->mainBuilder.SetInsertPoint(loopBody);
cgi->builder.SetInsertPoint(loopBody);
cgi->pushBracedBlock(this, loopBody, loopEnd);

this->body->codegen(cgi);
@@ -106,11 +106,11 @@ Result_t WhileLoop::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Val

// put a branch to see if we will go back
llvm::Value* condInside = this->cond->codegen(cgi).result.first;
cgi->mainBuilder.CreateCondBr(condInside, loopBody, loopEnd);
cgi->builder.CreateCondBr(condInside, loopBody, loopEnd);


// parentFunc->getBasicBlockList().push_back(loopEnd);
cgi->mainBuilder.SetInsertPoint(loopEnd);
cgi->builder.SetInsertPoint(loopEnd);

return Result_t(0, 0);
}
6 source/Codegen/TypeHandling/EnumerationCodegen.cpp
View file
@@ -50,10 +50,10 @@ namespace Codegen
// strong enum.
// create a temp alloca, then use GEP to set the value, then return.
llvm::Value* alloca = cgi->allocateInstanceInBlock(tp->first);
llvm::Value* gep = cgi->mainBuilder.CreateStructGEP(alloca, 0);
llvm::Value* gep = cgi->builder.CreateStructGEP(alloca, 0);

cgi->mainBuilder.CreateStore(res.result.first, gep);
return Result_t(cgi->mainBuilder.CreateLoad(alloca), alloca);
cgi->builder.CreateStore(res.result.first, gep);
return Result_t(cgi->builder.CreateLoad(alloca), alloca);
}
}

12 source/Codegen/TypeHandling/ExtensionCodegen.cpp
View file
@@ -19,13 +19,13 @@ llvm::Function* Extension::createAutomaticInitialiser(CodegenInstance* cgi, llvm
{
// generate initialiser
llvm::Function* defaultInitFunc = llvm::Function::Create(llvm::FunctionType::get(llvm::Type::getVoidTy(llvm::getGlobalContext()), llvm::PointerType::get(stype, 0), false), llvm::Function::ExternalLinkage,
"__automatic_init__" + this->mangledName + ".ext" + std::to_string(extIndex), cgi->mainModule);
"__automatic_init__" + this->mangledName + ".ext" + std::to_string(extIndex), cgi->module);

cgi->addFunctionToScope(defaultInitFunc->getName(), FuncPair_t(defaultInitFunc, 0));
llvm::BasicBlock* iblock = llvm::BasicBlock::Create(llvm::getGlobalContext(), "initialiser", defaultInitFunc);

llvm::BasicBlock* oldIP = cgi->mainBuilder.GetInsertBlock();
cgi->mainBuilder.SetInsertPoint(iblock);
llvm::BasicBlock* oldIP = cgi->builder.GetInsertBlock();
cgi->builder.SetInsertPoint(iblock);

// create the local instance of reference to self
llvm::Value* self = defaultInitFunc->arg_begin();
@@ -38,16 +38,16 @@ llvm::Function* Extension::createAutomaticInitialiser(CodegenInstance* cgi, llvm
int i = memberBeginOffset + this->nameMap[var->name];
iceAssert(i >= 0);

llvm::Value* ptr = cgi->mainBuilder.CreateStructGEP(self, i, "memberPtr_" + var->name);
llvm::Value* ptr = cgi->builder.CreateStructGEP(self, i, "memberPtr_" + var->name);

auto r = var->initVal ? var->initVal->codegen(cgi).result : ValPtr_t(0, 0);
var->doInitialValue(cgi, cgi->getType(var->type.strType), r.first, r.second, ptr, false);
}

cgi->mainBuilder.CreateRetVoid();
cgi->builder.CreateRetVoid();
llvm::verifyFunction(*defaultInitFunc);

cgi->mainBuilder.SetInsertPoint(oldIP);
cgi->builder.SetInsertPoint(oldIP);
return defaultInitFunc;
}

32 source/Codegen/TypeHandling/MemberAccessCodegen.cpp
View file
@@ -123,7 +123,7 @@ Result_t MemberAccess::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::
else
{
selfPtr = cgi->allocateInstanceInBlock(type);
cgi->mainBuilder.CreateStore(self, selfPtr);
cgi->builder.CreateStore(self, selfPtr);
}
}

@@ -149,12 +149,12 @@ Result_t MemberAccess::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::
if(wasSelfPtr)
{
if(selfPtr->getType()->isPointerTy() && selfPtr->getType()->getPointerElementType()->isPointerTy())
selfPtr = cgi->mainBuilder.CreateLoad(selfPtr);
selfPtr = cgi->builder.CreateLoad(selfPtr);
}
else
{
if(self->getType()->isPointerTy() && self->getType()->getPointerElementType()->isPointerTy())
self = cgi->mainBuilder.CreateLoad(self);
self = cgi->builder.CreateLoad(self);
}
}

@@ -190,7 +190,7 @@ Result_t MemberAccess::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::
if(n->ival >= type->getStructNumElements())
error(cgi, this, "Tuple does not have %d elements, only %d", (int) n->ival + 1, type->getStructNumElements());

llvm::Value* gep = cgi->mainBuilder.CreateStructGEP(selfPtr, n->ival);
llvm::Value* gep = cgi->builder.CreateStructGEP(selfPtr, n->ival);

// if the lhs is immutable, don't give a pointer.
bool immut = false;
@@ -202,7 +202,7 @@ Result_t MemberAccess::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::
immut = vd->immutable;
}

return Result_t(cgi->mainBuilder.CreateLoad(gep), immut ? 0 : gep);
return Result_t(cgi->builder.CreateLoad(gep), immut ? 0 : gep);
}
else if(pair->second.second == TypeKind::Struct)
{
@@ -359,10 +359,10 @@ static Result_t doFunctionCall(CodegenInstance* cgi, FuncCall* fc, llvm::Value*
if(!lcallee)
error(fc, "(%s:%d) -> Internal check failed: failed to find function %s", __FILE__, __LINE__, fc->name.c_str());

lcallee = cgi->mainModule->getFunction(lcallee->getName());
lcallee = cgi->module->getFunction(lcallee->getName());
iceAssert(lcallee);

return Result_t(cgi->mainBuilder.CreateCall(lcallee, args), 0);
return Result_t(cgi->builder.CreateCall(lcallee, args), 0);
}


@@ -397,8 +397,8 @@ static Result_t doComputedProperty(CodegenInstance* cgi, VarRef* var, ComputedPr
// to return something. We're still used in a binOp though, so...

// create a fake alloca to return to them.
lcallee = cgi->mainModule->getFunction(lcallee->getName());
return Result_t(cgi->mainBuilder.CreateCall(lcallee, args), cgi->allocateInstanceInBlock(_rhs->getType()));
lcallee = cgi->module->getFunction(lcallee->getName());
return Result_t(cgi->builder.CreateCall(lcallee, args), cgi->allocateInstanceInBlock(_rhs->getType()));
}
else
{
@@ -415,9 +415,9 @@ static Result_t doComputedProperty(CodegenInstance* cgi, VarRef* var, ComputedPr
if(!lcallee)
error(var, "?!??!!");

lcallee = cgi->mainModule->getFunction(lcallee->getName());
lcallee = cgi->module->getFunction(lcallee->getName());
std::vector<llvm::Value*> args { ref };
return Result_t(cgi->mainBuilder.CreateCall(lcallee, args), 0);
return Result_t(cgi->builder.CreateCall(lcallee, args), 0);
}
}

@@ -428,8 +428,8 @@ static Result_t doVariable(CodegenInstance* cgi, VarRef* var, llvm::Value* ref,
// if we are a Struct* instead of just a Struct, we can just use pair.first since it's already a pointer.
iceAssert(ref);

llvm::Value* ptr = cgi->mainBuilder.CreateStructGEP(ref, i, "memberPtr_" + var->name);
llvm::Value* val = cgi->mainBuilder.CreateLoad(ptr);
llvm::Value* ptr = cgi->builder.CreateStructGEP(ref, i, "memberPtr_" + var->name);
llvm::Value* val = cgi->builder.CreateLoad(ptr);

if(str->members[i]->immutable)
ptr = 0;
@@ -444,14 +444,14 @@ static Result_t doVariable(CodegenInstance* cgi, VarRef* var, llvm::Value* ref,
static Result_t getStaticVariable(CodegenInstance* cgi, Expr* user, StructBase* str, std::string name)
{
std::string mangledName = cgi->mangleMemberFunction(str, name, std::deque<Ast::Expr*>());
if(llvm::GlobalVariable* gv = cgi->mainModule->getGlobalVariable(mangledName))
if(llvm::GlobalVariable* gv = cgi->module->getGlobalVariable(mangledName))
{
// todo: another kinda hacky thing.
// this is present in some parts of the code, i don't know how many.
// basically, if the thing is supposed to be immutable, we're not going to return
// the ptr/ref value.

return Result_t(cgi->mainBuilder.CreateLoad(gv), gv->isConstant() ? 0 : gv);
return Result_t(cgi->builder.CreateLoad(gv), gv->isConstant() ? 0 : gv);
}

error(cgi, user, "Struct '%s' has no such static member '%s'", str->name.c_str(), name.c_str());
@@ -597,7 +597,7 @@ static Result_t _doStaticAccess(CodegenInstance* cgi, StructBase* str, llvm::Val
iceAssert(res.result.first);
llvm::Value* _ref = cgi->allocateInstanceInBlock(res.result.first->getType());

cgi->mainBuilder.CreateStore(res.result.first, _ref);
cgi->builder.CreateStore(res.result.first, _ref);
newref = _ref;
}

22 source/Codegen/TypeHandling/StructCodegen.cpp
View file
@@ -43,11 +43,11 @@ Result_t Struct::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*
llvm::StructType* str = llvm::cast<llvm::StructType>(_type->first);

// generate initialiser
llvm::Function* defaultInitFunc = llvm::Function::Create(llvm::FunctionType::get(llvm::Type::getVoidTy(llvm::getGlobalContext()), llvm::PointerType::get(str, 0), false), linkageType, "__automatic_init__" + this->mangledName, cgi->mainModule);
llvm::Function* defaultInitFunc = llvm::Function::Create(llvm::FunctionType::get(llvm::Type::getVoidTy(llvm::getGlobalContext()), llvm::PointerType::get(str, 0), false), linkageType, "__automatic_init__" + this->mangledName, cgi->module);

cgi->addFunctionToScope(defaultInitFunc->getName(), FuncPair_t(defaultInitFunc, 0));
llvm::BasicBlock* iblock = llvm::BasicBlock::Create(llvm::getGlobalContext(), "initialiser", defaultInitFunc);
cgi->mainBuilder.SetInsertPoint(iblock);
cgi->builder.SetInsertPoint(iblock);

// create the local instance of reference to self
llvm::Value* self = &defaultInitFunc->getArgumentList().front();
@@ -61,7 +61,7 @@ Result_t Struct::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*
int i = this->nameMap[var->name];
iceAssert(i >= 0);

llvm::Value* ptr = cgi->mainBuilder.CreateStructGEP(self, i, "memberPtr_" + var->name);
llvm::Value* ptr = cgi->builder.CreateStructGEP(self, i, "memberPtr_" + var->name);

auto r = var->initVal ? var->initVal->codegen(cgi).result : ValPtr_t(0, 0);
var->doInitialValue(cgi, cgi->getType(var->type.strType), r.first, r.second, ptr, false);
@@ -75,7 +75,7 @@ Result_t Struct::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*
std::string varname = cgi->mangleMemberFunction(this, var->name, std::deque<Ast::Expr*>());

// generate a global variable (sorry!).
llvm::GlobalValue* gv = new llvm::GlobalVariable(*cgi->mainModule, var->inferredLType, var->immutable, llvm::GlobalValue::ExternalLinkage, llvm::Constant::getNullValue(var->inferredLType), varname);
llvm::GlobalValue* gv = new llvm::GlobalVariable(*cgi->module, var->inferredLType, var->immutable, llvm::GlobalValue::ExternalLinkage, llvm::Constant::getNullValue(var->inferredLType), varname);

if(var->inferredLType->isStructTy())
{
@@ -132,12 +132,12 @@ Result_t Struct::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*
{
for(llvm::Function* f : extensionInitialisers)
{
llvm::Function* actual = cgi->mainModule->getFunction(f->getName());
cgi->mainBuilder.CreateCall(actual, self);
llvm::Function* actual = cgi->module->getFunction(f->getName());
cgi->builder.CreateCall(actual, self);
}
}

cgi->mainBuilder.CreateRetVoid();
cgi->builder.CreateRetVoid();
llvm::verifyFunction(*defaultInitFunc);


@@ -205,7 +205,7 @@ Result_t Struct::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*
// pass 1
for(Func* f : this->funcs)
{
llvm::BasicBlock* ob = cgi->mainBuilder.GetInsertBlock();
llvm::BasicBlock* ob = cgi->builder.GetInsertBlock();
bool isOpOverload = f->decl->name.find("operator#") == 0;
if(isOpOverload)
f->decl->name = f->decl->name.substr(strlen("operator#"));
@@ -228,7 +228,7 @@ Result_t Struct::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*
this->initFuncs.push_back(llvm::cast<llvm::Function>(val));


cgi->mainBuilder.SetInsertPoint(ob);
cgi->builder.SetInsertPoint(ob);
this->lfuncs.push_back(llvm::cast<llvm::Function>(val));

if(isOpOverload)
@@ -244,7 +244,7 @@ Result_t Struct::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*
// pass 2
for(Func* f : this->funcs)
{
llvm::BasicBlock* ob = cgi->mainBuilder.GetInsertBlock();
llvm::BasicBlock* ob = cgi->builder.GetInsertBlock();

if(f->decl->name == "init")
{
@@ -260,7 +260,7 @@ Result_t Struct::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*
}

f->codegen(cgi);
cgi->mainBuilder.SetInsertPoint(ob);
cgi->builder.SetInsertPoint(ob);
}

if(this->initFuncs.size() == 0)
6 source/Codegen/TypeHandling/TupleCodegen.cpp
View file
@@ -63,7 +63,7 @@ Result_t Tuple::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*

for(unsigned int i = 0; i < strtype->getStructNumElements(); i++)
{
llvm::Value* member = cgi->mainBuilder.CreateStructGEP(gep, i);
llvm::Value* member = cgi->builder.CreateStructGEP(gep, i);
llvm::Value* val = this->values[i]->codegen(cgi).result.first;

// printf("%s -> %s\n", cgi->getReadableType(val).c_str(), cgi->getReadableType(member->getType()->getPointerElementType()).c_str());
@@ -73,10 +73,10 @@ Result_t Tuple::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*
error(cgi, this, "Element %d of tuple is mismatched, expected '%s' but got '%s'", i,
cgi->getReadableType(member->getType()->getPointerElementType()).c_str(), cgi->getReadableType(val).c_str());

cgi->mainBuilder.CreateStore(val, member);
cgi->builder.CreateStore(val, member);
}

return Result_t(cgi->mainBuilder.CreateLoad(gep), gep);
return Result_t(cgi->builder.CreateLoad(gep), gep);
}


12 source/Codegen/TypeHandling/TypeUtils.cpp
View file
@@ -91,7 +91,7 @@ namespace Codegen
return alloca; // fail.
}

return this->mainBuilder.CreateStructGEP(alloca, 0);
return this->builder.CreateStructGEP(alloca, 0);
}

return alloca;
@@ -419,7 +419,7 @@ namespace Codegen

llvm::AllocaInst* CodegenInstance::allocateInstanceInBlock(llvm::Type* type, std::string name)
{
return this->mainBuilder.CreateAlloca(type, 0, name == "" ? "" : name);
return this->builder.CreateAlloca(type, 0, name == "" ? "" : name);
}

llvm::AllocaInst* CodegenInstance::allocateInstanceInBlock(VarDecl* var)
@@ -529,7 +529,7 @@ namespace Codegen
}

if(shouldCast)
right = this->mainBuilder.CreateIntCast(right, target, false);
right = this->builder.CreateIntCast(right, target, false);
}

// check if we're passing a string to a function expecting an Int8*
@@ -545,13 +545,13 @@ namespace Codegen

// cast the RHS to the LHS
iceAssert(rhsPtr);
llvm::Value* ret = this->mainBuilder.CreateStructGEP(rhsPtr, 0);
right = this->mainBuilder.CreateLoad(ret); // mutating
llvm::Value* ret = this->builder.CreateStructGEP(rhsPtr, 0);
right = this->builder.CreateLoad(ret); // mutating
}
}
else if(target->isFloatingPointTy() && right->getType()->isIntegerTy())
{
right = this->mainBuilder.CreateSIToFP(right, target);
right = this->builder.CreateSIToFP(right, target);
}
}

6 source/Codegen/TypeofCodegen.cpp
View file
@@ -48,10 +48,10 @@ Result_t Typeof::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*
iceAssert(enr);

llvm::Value* wrapper = cgi->allocateInstanceInBlock(tp->first, "typeof_tmp");
llvm::Value* gep = cgi->mainBuilder.CreateStructGEP(wrapper, 0, "wrapped");
llvm::Value* gep = cgi->builder.CreateStructGEP(wrapper, 0, "wrapped");

cgi->mainBuilder.CreateStore(enr->cases[index - 1].second->codegen(cgi).result.first, gep);
return Result_t(cgi->mainBuilder.CreateLoad(wrapper), wrapper);
cgi->builder.CreateStore(enr->cases[index - 1].second->codegen(cgi).result.first, gep);
return Result_t(cgi->builder.CreateLoad(wrapper), wrapper);
}


8 source/Codegen/UnaryOpCodegen.cpp
View file
@@ -17,10 +17,10 @@ Result_t UnaryOp::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value
switch(this->op)
{
case ArithmeticOp::LogicalNot:
return Result_t(cgi->mainBuilder.CreateICmpEQ(res.result.first, llvm::Constant::getNullValue(res.result.first->getType())), res.result.second);
return Result_t(cgi->builder.CreateICmpEQ(res.result.first, llvm::Constant::getNullValue(res.result.first->getType())), res.result.second);

case ArithmeticOp::Minus:
return Result_t(cgi->mainBuilder.CreateNeg(res.result.first), res.result.second);
return Result_t(cgi->builder.CreateNeg(res.result.first), res.result.second);

case ArithmeticOp::Plus:
return res;
@@ -29,7 +29,7 @@ Result_t UnaryOp::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value
if(!res.result.first->getType()->isPointerTy())
error(cgi, this, "Cannot dereference non-pointer type!");

return Result_t(cgi->mainBuilder.CreateLoad(res.result.first), res.result.first);
return Result_t(cgi->builder.CreateLoad(res.result.first), res.result.first);

case ArithmeticOp::AddrOf:
if(!res.result.second)
@@ -38,7 +38,7 @@ Result_t UnaryOp::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value
return Result_t(res.result.second, 0);

case ArithmeticOp::BitwiseNot:
return Result_t(cgi->mainBuilder.CreateNot(res.result.first), res.result.second);
return Result_t(cgi->builder.CreateNot(res.result.first), res.result.second);

default:
error(cgi, this, "(%s:%d) -> Internal check failed: invalid unary operator", __FILE__, __LINE__);
18 source/Codegen/VarCodegen.cpp
View file
@@ -17,7 +17,7 @@ Result_t VarRef::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value*
if(!val)
GenError::unknownSymbol(cgi, this, this->name, SymbolType::Variable);

return Result_t(cgi->mainBuilder.CreateLoad(val, this->name), val);
return Result_t(cgi->builder.CreateLoad(val, this->name), val);
}


@@ -82,7 +82,7 @@ llvm::Value* VarDecl::doInitialValue(Codegen::CodegenInstance* cgi, TypePair_t*
std::vector<llvm::Value*> args { unwrappedAi };

llvm::Function* initfunc = cgi->getStructInitialiser(this, cmplxtype, args);
val = cgi->mainBuilder.CreateCall(initfunc, args);
val = cgi->builder.CreateCall(initfunc, args);
}
}
}
@@ -106,7 +106,7 @@ llvm::Value* VarDecl::doInitialValue(Codegen::CodegenInstance* cgi, TypePair_t*
bool wasImmut = this->immutable;
this->immutable = false;
auto res = cgi->doBinOpAssign(this, new VarRef(this->posinfo, this->name), this->initVal,
ArithmeticOp::Assign, cgi->mainBuilder.CreateLoad(ai), ai, val, valptr);
ArithmeticOp::Assign, cgi->builder.CreateLoad(ai), ai, val, valptr);

this->immutable = wasImmut;
return res.result.first;
@@ -116,7 +116,7 @@ llvm::Value* VarDecl::doInitialValue(Codegen::CodegenInstance* cgi, TypePair_t*
if(!val)
val = cgi->getDefaultValue(this);

cgi->mainBuilder.CreateStore(val, ai);
cgi->builder.CreateStore(val, ai);
return val;
}
else if(cmplxtype && this->initVal)
@@ -128,13 +128,13 @@ llvm::Value* VarDecl::doInitialValue(Codegen::CodegenInstance* cgi, TypePair_t*
if(ai->getType()->getPointerElementType() != val->getType())
GenError::invalidAssignment(cgi, this, ai->getType()->getPointerElementType(), val->getType());

cgi->mainBuilder.CreateStore(val, ai);
cgi->builder.CreateStore(val, ai);
return val;
}
else
{
if(valptr)
val = cgi->mainBuilder.CreateLoad(valptr);
val = cgi->builder.CreateLoad(valptr);

else
return val;
@@ -169,7 +169,7 @@ llvm::Value* VarDecl::doInitialValue(Codegen::CodegenInstance* cgi, TypePair_t*
// if((uint64_t) n->ival < max)


val = cgi->mainBuilder.CreateIntCast(val, ai->getType()->getPointerElementType(), false);
val = cgi->builder.CreateIntCast(val, ai->getType()->getPointerElementType(), false);


// }
@@ -180,7 +180,7 @@ llvm::Value* VarDecl::doInitialValue(Codegen::CodegenInstance* cgi, TypePair_t*
}
}

cgi->mainBuilder.CreateStore(val, ai);
cgi->builder.CreateStore(val, ai);
return val;
}

@@ -264,7 +264,7 @@ Result_t VarDecl::codegen(CodegenInstance* cgi, llvm::Value* lhsPtr, llvm::Value
}
else
{
ai = new llvm::GlobalVariable(*cgi->mainModule, this->inferredLType, this->immutable, llvm::GlobalValue::InternalLinkage, llvm::Constant::getNullValue(this->inferredLType), this->name);
ai = new llvm::GlobalVariable(*cgi->module, this->inferredLType, this->immutable, llvm::GlobalValue::InternalLinkage, llvm::Constant::getNullValue(this->inferredLType), this->name);
}

if(this->initVal)
10 source/Compiler.cpp
View file
@@ -116,7 +116,7 @@ namespace Compiler
Codegen::CodegenInstance* rcgi = new Codegen::CodegenInstance();
r = compileFile(fname, list, rootmap, modules, rcgi);

modules.push_back(rcgi->mainModule);
modules.push_back(rcgi->module);
rootmap[imp->module] = r;
delete rcgi;
}
@@ -155,9 +155,9 @@ namespace Compiler

Codegen::doCodegen(filename, root, cgi);

// cgi->mainModule->dump();
// cgi->module->dump();

llvm::verifyModule(*cgi->mainModule, &llvm::errs());
llvm::verifyModule(*cgi->module, &llvm::errs());
Codegen::writeBitcode(filename, cgi);

size_t lastdot = filename.find_last_of(".");
@@ -179,14 +179,14 @@ namespace Compiler
tgt = "-target " + getTarget();


if(!Compiler::getIsCompileOnly() && !cgi->mainModule->getFunction("main"))
if(!Compiler::getIsCompileOnly() && !cgi->module->getFunction("main"))
{
error(0, "No main() function, a program cannot be compiled.");
}



std::string oname = outname.empty() ? (foldername + "/" + cgi->mainModule->getModuleIdentifier()).c_str() : outname.c_str();
std::string oname = outname.empty() ? (foldername + "/" + cgi->module->getModuleIdentifier()).c_str() : outname.c_str();
// compile it by invoking clang on the bitcode
char* inv = new char[1024];
snprintf(inv, 1024, "llvm-link -o '%s.bc'", oname.c_str());
2 source/TypeInfo/TypeInfoGeneration.cpp
View file
@@ -164,7 +164,7 @@ namespace TypeInfo
}

#if 0
printf("Final type list for module %s\n{\n", cgi->mainModule->getModuleIdentifier().c_str());
printf("Final type list for module %s\n{\n", cgi->module->getModuleIdentifier().c_str());

int i = 1;
for(auto c : enr->cases)
4 source/include/codegen.h
View file
@@ -45,7 +45,7 @@ namespace Codegen
bool isStructCodegen = false;

Ast::Root* rootNode;
llvm::Module* mainModule;
llvm::Module* module;
llvm::FunctionPassManager* Fpm;
std::deque<SymTab_t> symTabStack;
llvm::ExecutionEngine* execEngine;
@@ -60,7 +60,7 @@ namespace Codegen
std::deque<FuncMap_t> funcStack;
std::deque<Ast::Func*> funcScopeStack;

llvm::IRBuilder<> mainBuilder = llvm::IRBuilder<>(llvm::getGlobalContext());
llvm::IRBuilder<> builder = llvm::IRBuilder<>(llvm::getGlobalContext());


std::map<llvm::GlobalVariable*, llvm::Function*> globalConstructors;
32 source/main.cpp
View file
@@ -287,7 +287,7 @@ int main(int argc, char* argv[])
// needs to be done first, for the weird constructor fiddling below.
if(Compiler::runProgramWithJit)
{
llvm::Linker linker = llvm::Linker(cgi->mainModule);
llvm::Linker linker = llvm::Linker(cgi->module);
for(auto mod : modulelist)
linker.linkInModule(mod);
}
@@ -315,7 +315,7 @@ int main(int argc, char* argv[])
{
if(pair.second->globalConstructorTrampoline != 0)
{
llvm::Function* constr = cgi->mainModule->getFunction(pair.second->globalConstructorTrampoline->getName());
llvm::Function* constr = cgi->module->getFunction(pair.second->globalConstructorTrampoline->getName());
if(!constr)
{
if(Compiler::runProgramWithJit)
@@ -325,7 +325,7 @@ int main(int argc, char* argv[])
else
{
// declare it.
constr = llvm::cast<llvm::Function>(cgi->mainModule->getOrInsertFunction(pair.second->globalConstructorTrampoline->getName(), pair.second->globalConstructorTrampoline->getFunctionType()));
constr = llvm::cast<llvm::Function>(cgi->module->getOrInsertFunction(pair.second->globalConstructorTrampoline->getName(), pair.second->globalConstructorTrampoline->getFunctionType()));
}
}

@@ -335,33 +335,33 @@ int main(int argc, char* argv[])

llvm::FunctionType* ft = llvm::FunctionType::get(llvm::Type::getVoidTy(llvm::getGlobalContext()), false);
llvm::Function* gconstr = llvm::Function::Create(ft, llvm::GlobalValue::ExternalLinkage,
"__global_constructor_top_level__", cgi->mainModule);
"__global_constructor_top_level__", cgi->module);

llvm::BasicBlock* iblock = llvm::BasicBlock::Create(llvm::getGlobalContext(), "initialiser", gconstr);
cgi->mainBuilder.SetInsertPoint(iblock);
cgi->builder.SetInsertPoint(iblock);

for(auto f : constructors)
{
cgi->mainBuilder.CreateCall(f);
cgi->builder.CreateCall(f);
}

cgi->mainBuilder.CreateRetVoid();
cgi->builder.CreateRetVoid();




if(!Compiler::getNoAutoGlobalConstructor())
{
// insert a call at the beginning of main().
llvm::Function* mainfunc = cgi->mainModule->getFunction("main");
llvm::Function* mainfunc = cgi->module->getFunction("main");

llvm::BasicBlock* entry = &mainfunc->getEntryBlock();
llvm::BasicBlock* f = llvm::BasicBlock::Create(cgi->getContext(), "__main_entry", mainfunc);

f->moveBefore(entry);
cgi->mainBuilder.SetInsertPoint(f);
cgi->mainBuilder.CreateCall(gconstr);
cgi->mainBuilder.CreateBr(entry);
cgi->builder.SetInsertPoint(f);
cgi->builder.CreateCall(gconstr);
cgi->builder.CreateBr(entry);
}
}

@@ -394,14 +394,14 @@ int main(int argc, char* argv[])
// all linked already.
// dump here, before the output.
if(Compiler::printModule)
cgi->mainModule->dump();
cgi->module->dump();

iceAssert(cgi->execEngine);

if(cgi->mainModule->getFunction("main") != 0)
if(cgi->module->getFunction("main") != 0)
{
std::string err;
llvm::Module* clone = llvm::CloneModule(cgi->mainModule);
llvm::Module* clone = llvm::CloneModule(cgi->module);
llvm::ExecutionEngine* ee = llvm::EngineBuilder(std::unique_ptr<llvm::Module>(clone))
.setErrorStr(&err)
.setMCJITMemoryManager(llvm::make_unique<llvm::SectionMemoryManager>())
@@ -431,14 +431,14 @@ int main(int argc, char* argv[])
remove(s.c_str());

if(Compiler::printModule && !Compiler::getRunProgramWithJit())
cgi->mainModule->dump();
cgi->module->dump();

if(Compiler::dumpModule)
{
// std::string err_info;
// llvm::raw_fd_ostream out((outname + ".ir").c_str(), err_info, llvm::sys::fs::OpenFlags::F_None);

// out << *(cgi->mainModule);
// out << *(cgi->module);
// out.close();

fprintf(stderr, "enosup\n");