D/ldc
1
0
Fork 0
mirror of https://github.com/xomboverlord/ldc.git synced 2026-04-16 00:39:02 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

[svn r221] Update: Switched to the 2.3 LLVM svn branch, http://llvm.org/svn/llvm-project/llvm/branches/release_23 .

Browse Source 
Fixed: Implemented volatile statements. Uses the LLVM memory barrier intrinsic, closes #21 .
This commit is contained in:
Tomas Lindquist Olsen
2008-05-13 17:58:11 +02:00
parent 0d96635e19
commit 3365b4c02f
18 changed files with 318 additions and 239 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
dmd/mars.c
View File

@@ -158,7 +158,7 @@ extern void backend_term();
void usage()
{
printf("LLVM D Compiler %s (based on DMD %s and LLVM 2.2)\n%s\n%s\n",
printf("LLVM D Compiler %s (based on DMD %s and LLVM 2.3)\n%s\n%s\n",
global.llvmdc_version, global.version, global.copyright, global.written);
printf("\
D Language Documentation: http://www.digitalmars.com/d/1.0/index.html\n\

12
gen/arrays.cpp
View File

@@ -248,7 +248,7 @@ void DtoArrayInit(llvm::Value* ptr, llvm::Value* dim, llvm::Value* val)
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, funcname);
assert(fn);
Logger::cout() << "calling array init function: " << *fn <<'\n';
llvm::CallInst* call = new llvm::CallInst(fn, args.begin(), args.end(), "", gIR->scopebb());
llvm::CallInst* call = llvm::CallInst::Create(fn, args.begin(), args.end(), "", gIR->scopebb());
call->setCallingConv(llvm::CallingConv::C);
}
@@ -444,7 +444,7 @@ void DtoArrayCopySlices(DSliceValue* dst, DSliceValue* src)
llargs[2] = sz1;
llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
}
void DtoArrayCopyToSlice(DSliceValue* dst, DValue* src)
@@ -464,7 +464,7 @@ void DtoArrayCopyToSlice(DSliceValue* dst, DValue* src)
llargs[2] = sz1;
llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
@@ -487,7 +487,7 @@ void DtoStaticArrayCopy(llvm::Value* dst, llvm::Value* src)
llargs[2] = n;
llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
@@ -579,7 +579,7 @@ DSliceValue* DtoCatAssignElement(DValue* array, Expression* exp)
DSliceValue* slice = DtoResizeDynArray(array->getType(), array, newdim);
llvm::Value* ptr = slice->ptr;
ptr = new llvm::GetElementPtrInst(ptr, idx, "tmp", gIR->scopebb());
ptr = llvm::GetElementPtrInst::Create(ptr, idx, "tmp", gIR->scopebb());
DValue* dptr = new DVarValue(exp->type, ptr, true);
@@ -897,7 +897,7 @@ llvm::Value* DtoArrayCastLength(llvm::Value* len, const llvm::Type* elemty, cons
args.push_back(llvm::ConstantInt::get(DtoSize_t(), nsz, false));
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_array_cast_len");
return new llvm::CallInst(fn, args.begin(), args.end(), "tmp", gIR->scopebb());
return llvm::CallInst::Create(fn, args.begin(), args.end(), "tmp", gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////

18
gen/classes.cpp
View File

@@ -883,7 +883,7 @@ void DtoInitClass(TypeClass* tc, llvm::Value* dst)
llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false);
llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
@@ -911,7 +911,7 @@ DValue* DtoCallClassCtor(TypeClass* type, CtorDeclaration* ctor, Array* argument
a = DtoBitCast(a, aty);
ctorargs.push_back(a);
}
llvm::CallInst* call = new llvm::CallInst(fn, ctorargs.begin(), ctorargs.end(), "tmp", gIR->scopebb());
llvm::CallInst* call = llvm::CallInst::Create(fn, ctorargs.begin(), ctorargs.end(), "tmp", gIR->scopebb());
call->setCallingConv(DtoCallingConv(LINKd));
return new DImValue(type, call, false);
@@ -926,7 +926,7 @@ void DtoCallClassDtors(TypeClass* tc, llvm::Value* instance)
{
FuncDeclaration* fd = (FuncDeclaration*)arr->data[i];
assert(fd->ir.irFunc->func);
new llvm::CallInst(fd->ir.irFunc->func, instance, "", gIR->scopebb());
llvm::CallInst::Create(fd->ir.irFunc->func, instance, "", gIR->scopebb());
}
}
@@ -1162,7 +1162,7 @@ llvm::Value* DtoIndexClass(llvm::Value* ptr, ClassDeclaration* cd, Type* t, unsi
ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp");
//Logger::cout() << "indexing: " << *ptr << '\n';
if (vd->ir.irField->indexOffset)
ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
ptr = llvm::GetElementPtrInst::Create(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
//Logger::cout() << "indexing: " << *ptr << '\n';
return ptr;
}
@@ -1175,7 +1175,7 @@ llvm::Value* DtoIndexClass(llvm::Value* ptr, ClassDeclaration* cd, Type* t, unsi
ptr = DtoGEP(ptr, idxs, "tmp");
if (ptr->getType() != llt)
ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp");
ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
ptr = llvm::GetElementPtrInst::Create(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
std::vector<unsigned> tmp;
return DtoIndexStruct(ptr, ssd, t, os-vd->offset, tmp);
}
@@ -1198,7 +1198,7 @@ llvm::Value* DtoIndexClass(llvm::Value* ptr, ClassDeclaration* cd, Type* t, unsi
size_t llt_sz = getABITypeSize(llt->getContainedType(0));
assert(os % llt_sz == 0);
ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp");
return new llvm::GetElementPtrInst(ptr, DtoConstUint(os / llt_sz), "tmp", gIR->scopebb());
return llvm::GetElementPtrInst::Create(ptr, DtoConstUint(os / llt_sz), "tmp", gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
@@ -1360,12 +1360,12 @@ static llvm::Constant* build_class_dtor(ClassDeclaration* cd)
gname.append(cd->mangle());
gname.append("12__destructorMFZv");
llvm::Function* func = new llvm::Function(fnTy, DtoInternalLinkage(cd), gname, gIR->module);
llvm::Function* func = llvm::Function::Create(fnTy, DtoInternalLinkage(cd), gname, gIR->module);
llvm::Value* thisptr = func->arg_begin();
thisptr->setName("this");
llvm::BasicBlock* bb = new llvm::BasicBlock("entry", func);
LLVMBuilder builder(bb);
llvm::BasicBlock* bb = llvm::BasicBlock::Create("entry", func);
IRBuilder builder(bb);
for (size_t i = 0; i < cd->dtors.dim; i++)
{

4
gen/complex.cpp
View File

@@ -135,9 +135,9 @@ DValue* DtoComplex(Type* to, DValue* val)
llvm::Constant* undef = llvm::UndefValue::get(base);
llvm::Constant* zero;
if (ty == Tfloat32 || ty == Timaginary32 || ty == Tcomplex32)
zero = llvm::ConstantFP::get(llvm::Type::FloatTy, llvm::APFloat(0.0f));
zero = llvm::ConstantFP::get(llvm::APFloat(0.0f));
else if (ty == Tfloat64 || ty == Timaginary64 || ty == Tcomplex64 || ty == Tfloat80 || ty == Timaginary80 || ty == Tcomplex80)
zero = llvm::ConstantFP::get(llvm::Type::DoubleTy, llvm::APFloat(0.0));
zero = llvm::ConstantFP::get(llvm::APFloat(0.0));
if (t->isimaginary()) {
return new DComplexValue(to, zero, val->getRVal());

8
gen/dwarftypes.cpp
View File

@@ -155,25 +155,25 @@ void RegisterDwarfSymbols(llvm::Module* mod) {
// Function Declarations
Function* func_llvm_dbg_func_start = new Function(
Function* func_llvm_dbg_func_start = Function::Create(
/*Type=*/FuncTy_3,
/*Linkage=*/GlobalValue::ExternalLinkage,
/*Name=*/"llvm.dbg.func.start", mod); // (external, no body)
func_llvm_dbg_func_start->setCallingConv(CallingConv::C);
Function* func_llvm_dbg_stoppoint = new Function(
Function* func_llvm_dbg_stoppoint = Function::Create(
/*Type=*/FuncTy_4,
/*Linkage=*/GlobalValue::ExternalLinkage,
/*Name=*/"llvm.dbg.stoppoint", mod); // (external, no body)
func_llvm_dbg_stoppoint->setCallingConv(CallingConv::C);
Function* func_llvm_dbg_declare = new Function(
Function* func_llvm_dbg_declare = Function::Create(
/*Type=*/FuncTy_5,
/*Linkage=*/GlobalValue::ExternalLinkage,
/*Name=*/"llvm.dbg.declare", mod); // (external, no body)
func_llvm_dbg_declare->setCallingConv(CallingConv::C);
Function* func_llvm_dbg_region_end = new Function(
Function* func_llvm_dbg_region_end = Function::Create(
/*Type=*/FuncTy_3,
/*Linkage=*/GlobalValue::ExternalLinkage,
/*Name=*/"llvm.dbg.region.end", mod); // (external, no body)

35
gen/functions.cpp
View File

@@ -362,7 +362,7 @@ void DtoDeclareFunction(FuncDeclaration* fdecl)
const llvm::FunctionType* functype = DtoFunctionType(fdecl);
llvm::Function* func = vafunc ? vafunc : gIR->module->getFunction(mangled_name);
if (!func)
func = new llvm::Function(functype, DtoLinkage(fdecl), mangled_name, gIR->module);
func = llvm::Function::Create(functype, DtoLinkage(fdecl), mangled_name, gIR->module);
else
assert(func->getFunctionType() == functype);
@@ -489,8 +489,11 @@ void DtoDefineFunc(FuncDeclaration* fd)
if (fd->isMain())
gIR->emitMain = true;
llvm::BasicBlock* beginbb = new llvm::BasicBlock("entry",func);
llvm::BasicBlock* endbb = new llvm::BasicBlock("endentry",func);
std::string entryname("entry_");
entryname.append(fd->toPrettyChars());
llvm::BasicBlock* beginbb = llvm::BasicBlock::Create(entryname,func);
llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endentry",func);
//assert(gIR->scopes.empty());
gIR->scopes.push_back(IRScope(beginbb, endbb));
@@ -608,10 +611,10 @@ void DtoDefineFunc(FuncDeclaration* fd)
// pass the previous block into this block
if (global.params.symdebug) DtoDwarfFuncEnd(fd);
if (func->getReturnType() == llvm::Type::VoidTy) {
new llvm::ReturnInst(gIR->scopebb());
llvm::ReturnInst::Create(gIR->scopebb());
}
else {
new llvm::ReturnInst(llvm::UndefValue::get(func->getReturnType()), gIR->scopebb());
llvm::ReturnInst::Create(llvm::UndefValue::get(func->getReturnType()), gIR->scopebb());
}
}
}
@@ -636,10 +639,10 @@ void DtoDefineFunc(FuncDeclaration* fd)
else {
new llvm::UnreachableInst(lastbb);
/*if (func->getReturnType() == llvm::Type::VoidTy) {
new llvm::ReturnInst(lastbb);
llvm::ReturnInst::Create(lastbb);
}
else {
new llvm::ReturnInst(llvm::UndefValue::get(func->getReturnType()), lastbb);
llvm::ReturnInst::Create(llvm::UndefValue::get(func->getReturnType()), lastbb);
}*/
}
}
@@ -670,18 +673,18 @@ void DtoMain()
const llvm::Type* rettype = (const llvm::Type*)llvm::Type::Int32Ty;
llvm::FunctionType* functype = llvm::FunctionType::get(rettype, pvec, false);
llvm::Function* func = new llvm::Function(functype,llvm::GlobalValue::ExternalLinkage,"main",ir.module);
llvm::Function* func = llvm::Function::Create(functype,llvm::GlobalValue::ExternalLinkage,"main",ir.module);
llvm::BasicBlock* bb = new llvm::BasicBlock("entry",func);
llvm::BasicBlock* bb = llvm::BasicBlock::Create("entry",func);
// call static ctors
llvm::Function* fn = LLVM_D_GetRuntimeFunction(ir.module,"_moduleCtor");
llvm::Instruction* apt = new llvm::CallInst(fn,"",bb);
llvm::Instruction* apt = llvm::CallInst::Create(fn,"",bb);
// run unit tests if -unittest is provided
if (global.params.useUnitTests) {
fn = LLVM_D_GetRuntimeFunction(ir.module,"_moduleUnitTests");
llvm::Instruction* apt = new llvm::CallInst(fn,"",bb);
llvm::Instruction* apt = llvm::CallInst::Create(fn,"",bb);
}
// call user main function
@@ -709,22 +712,22 @@ void DtoMain()
ptr = DtoGEPi(a,0,1,"tmp",bb);
new llvm::StoreInst(arr,ptr,bb);
args.push_back(a);
new llvm::CallInst(mfn, args.begin(), args.end(), "", bb);
call = new llvm::CallInst(ir.mainFunc,a,"ret",bb);
llvm::CallInst::Create(mfn, args.begin(), args.end(), "", bb);
call = llvm::CallInst::Create(ir.mainFunc,a,"ret",bb);
}
else
{
// main with no arguments
call = new llvm::CallInst(ir.mainFunc,"ret",bb);
call = llvm::CallInst::Create(ir.mainFunc,"ret",bb);
}
call->setCallingConv(ir.mainFunc->getCallingConv());
// call static dtors
fn = LLVM_D_GetRuntimeFunction(ir.module,"_moduleDtor");
new llvm::CallInst(fn,"",bb);
llvm::CallInst::Create(fn,"",bb);
// return
new llvm::ReturnInst(call,bb);
llvm::ReturnInst::Create(call,bb);
}
//////////////////////////////////////////////////////////////////////////////////////////

5
gen/irstate.cpp
View File

@@ -57,6 +57,7 @@ IRState::IRState()
llvm_DeclareMemSet64 = NULL;
llvm_DeclareMemCpy32 = NULL;
llvm_DeclareMemCpy64 = NULL;
llvm_DeclareMemBarrier = NULL;
}
IrFunction* IRState::func()
@@ -120,9 +121,9 @@ bool IRState::scopereturned()
//////////////////////////////////////////////////////////////////////////////////////////
LLVMBuilder* IRBuilderHelper::operator->()
IRBuilder* IRBuilderHelper::operator->()
{
LLVMBuilder& b = state->scope().builder;
IRBuilder& b = state->scope().builder;
assert(b.GetInsertBlock() != NULL);
return &b;
}

5
gen/irstate.h
View File

@@ -32,7 +32,7 @@ struct IRScope
{
llvm::BasicBlock* begin;
llvm::BasicBlock* end;
LLVMBuilder builder;
IRBuilder builder;
IRScope();
IRScope(llvm::BasicBlock* b, llvm::BasicBlock* e);
@@ -53,7 +53,7 @@ struct IRLoopScope : IRScope
struct IRBuilderHelper
{
IRState* state;
LLVMBuilder* operator->();
IRBuilder* operator->();
};
struct IRExp
@@ -146,6 +146,7 @@ struct IRState
llvm::Function* llvm_DeclareMemSet64;
llvm::Function* llvm_DeclareMemCpy32;
llvm::Function* llvm_DeclareMemCpy64;
llvm::Function* llvm_DeclareMemBarrier;
};
#endif // LLVMDC_GEN_IRSTATE_H

4
gen/llvm.h
View File

@@ -13,7 +13,7 @@
#include "llvm/Target/TargetData.h"
#include "llvm/Support/LLVMBuilder.h"
using llvm::LLVMBuilder;
#include "llvm/Support/IRBuilder.h"
using llvm::IRBuilder;
#endif // GEN_LLVM_H

108
gen/runtime.cpp
View File

@@ -217,9 +217,9 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(stringTy);
types.push_back(intTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname3, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname3, M);
}
// void _d_assert_msg( char[] msg, char[] file, uint line )
@@ -230,7 +230,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(stringTy);
types.push_back(intTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
/////////////////////////////////////////////////////////////////////////////////////
@@ -243,7 +243,7 @@ static void LLVM_D_BuildRuntimeModule()
std::vector<const llvm::Type*> types;
types.push_back(typeInfoTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// void* _d_newarrayT(TypeInfo ti, size_t length)
@@ -255,8 +255,8 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(typeInfoTy);
types.push_back(sizeTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
}
// void* _d_arraysetlengthT(TypeInfo ti, size_t newlength, size_t plength, void* pdata)
@@ -270,8 +270,8 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(sizeTy);
types.push_back(voidPtrTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
}
// Object _d_newclass(ClassInfo ci)
@@ -280,7 +280,7 @@ static void LLVM_D_BuildRuntimeModule()
std::vector<const llvm::Type*> types;
types.push_back(classInfoTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
/////////////////////////////////////////////////////////////////////////////////////
@@ -296,7 +296,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(sizeTy); \
types.push_back(TY); \
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false); \
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
}
ARRAY_INIT(boolTy,"i1")
@@ -320,7 +320,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(voidPtrTy);
types.push_back(sizeTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
/////////////////////////////////////////////////////////////////////////////////////
@@ -335,8 +335,8 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(TY); \
types.push_back(rt_dg1()); \
const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false); \
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
}
STR_APPLY1(stringTy, "_aApplycw1", "_aApplycd1")
STR_APPLY1(wstringTy, "_aApplywc1", "_aApplywd1")
@@ -351,8 +351,8 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(TY); \
types.push_back(rt_dg2()); \
const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false); \
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
}
STR_APPLY2(stringTy, "_aApplycw2", "_aApplycd2")
STR_APPLY2(wstringTy, "_aApplywc2", "_aApplywd2")
@@ -367,8 +367,8 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(TY); \
types.push_back(rt_dg1()); \
const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false); \
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
}
STR_APPLY_R1(stringTy, "_aApplyRcw1", "_aApplyRcd1")
STR_APPLY_R1(wstringTy, "_aApplyRwc1", "_aApplyRwd1")
@@ -383,8 +383,8 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(TY); \
types.push_back(rt_dg2()); \
const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false); \
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
}
STR_APPLY_R2(stringTy, "_aApplyRcw2", "_aApplyRcd2")
STR_APPLY_R2(wstringTy, "_aApplyRwc2", "_aApplyRwd2")
@@ -404,7 +404,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(sizeTy);
types.push_back(sizeTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(sizeTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
/////////////////////////////////////////////////////////////////////////////////////
@@ -420,7 +420,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(rt_ptr(rt_ptr(byteTy)));
types.push_back(rt_array(stringTy->getContainedType(0)));
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
/////////////////////////////////////////////////////////////////////////////////////
@@ -434,7 +434,7 @@ static void LLVM_D_BuildRuntimeModule()
std::vector<const llvm::Type*> types;
types.push_back(voidPtrTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// cast interface
@@ -445,7 +445,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(voidPtrTy);
types.push_back(classInfoTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// dynamic cast
@@ -456,7 +456,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(objectTy);
types.push_back(classInfoTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
/////////////////////////////////////////////////////////////////////////////////////
@@ -472,8 +472,8 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(stringTy);
types.push_back(stringTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
}
// wchar[] _adReverseWchar(wchar[] a)
@@ -485,8 +485,8 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(wstringTy);
types.push_back(wstringTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
}
// Array _adReverse(Array a, size_t szelem)
@@ -497,7 +497,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(rt_array(byteTy));
types.push_back(sizeTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// Array _adDupT(TypeInfo ti, Array a)
@@ -508,7 +508,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(typeInfoTy);
types.push_back(rt_array(byteTy));
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// int _adEq(Array a1, Array a2, TypeInfo ti)
@@ -521,8 +521,8 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(rt_array(byteTy));
types.push_back(typeInfoTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
}
// int _adCmpChar(Array a1, Array a2)
@@ -532,7 +532,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(rt_array(byteTy));
types.push_back(rt_array(byteTy));
const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// Array _adSort(Array a, TypeInfo ti)
@@ -543,7 +543,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(rt_array(byteTy));
types.push_back(typeInfoTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
/////////////////////////////////////////////////////////////////////////////////////
@@ -556,7 +556,7 @@ static void LLVM_D_BuildRuntimeModule()
std::vector<const llvm::Type*> types;
types.push_back(aaTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(sizeTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// void* _aaGet(AA* aa, TypeInfo keyti, size_t valuesize, void* pkey)
@@ -568,7 +568,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(sizeTy);
types.push_back(voidPtrTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// void* _aaGetRvalue(AA aa, TypeInfo keyti, size_t valuesize, void* pkey)
@@ -580,7 +580,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(sizeTy);
types.push_back(voidPtrTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// void* _aaIn(AA aa, TypeInfo keyti, void* pkey)
@@ -591,7 +591,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(typeInfoTy);
types.push_back(voidPtrTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// void _aaDel(AA aa, TypeInfo keyti, void* pkey)
@@ -602,7 +602,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(typeInfoTy);
types.push_back(voidPtrTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// ArrayRet_t _aaValues(AA aa, size_t keysize, size_t valuesize)
@@ -614,7 +614,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(sizeTy);
types.push_back(sizeTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// void* _aaRehash(AA* paa, TypeInfo keyti)
@@ -624,7 +624,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(aaTy);
types.push_back(typeInfoTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// ArrayRet_t _aaKeys(AA aa, size_t keysize)
@@ -635,7 +635,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(aaTy);
types.push_back(sizeTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// int _aaApply(AA aa, size_t keysize, dg_t dg)
@@ -646,7 +646,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(sizeTy);
types.push_back(rt_dg1());
const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// int _aaApply2(AA aa, size_t keysize, dg2_t dg)
@@ -657,7 +657,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(sizeTy);
types.push_back(rt_dg1());
const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
/////////////////////////////////////////////////////////////////////////////////////
@@ -671,8 +671,8 @@ static void LLVM_D_BuildRuntimeModule()
std::string fname2("_moduleDtor");
std::vector<const llvm::Type*> types;
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
}
/////////////////////////////////////////////////////////////////////////////////////
@@ -685,7 +685,7 @@ static void LLVM_D_BuildRuntimeModule()
std::vector<const llvm::Type*> types;
types.push_back(voidPtrTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// Object _d_dynamic_cast(Object o, ClassInfo c)
@@ -695,7 +695,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(objectTy);
types.push_back(classInfoTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// Object _d_interface_cast(void* p, ClassInfo c)
@@ -705,7 +705,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(voidPtrTy);
types.push_back(classInfoTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
/////////////////////////////////////////////////////////////////////////////////////
@@ -718,7 +718,7 @@ static void LLVM_D_BuildRuntimeModule()
std::vector<const llvm::Type*> types;
types.push_back(objectTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
/////////////////////////////////////////////////////////////////////////////////////
@@ -732,7 +732,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(rt_array(rt_array2(byteTy)));
types.push_back(stringTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// int _d_switch_ustring(wchar[][] table, wchar[] ca)
@@ -742,7 +742,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(rt_array(rt_array2(shortTy)));
types.push_back(wstringTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
// int _d_switch_dstring(dchar[][] table, dchar[] ca)
@@ -752,7 +752,7 @@ static void LLVM_D_BuildRuntimeModule()
types.push_back(rt_array(rt_array2(intTy)));
types.push_back(dstringTy);
const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
}
}

189
gen/statements.cpp
View File

@@ -92,8 +92,13 @@ void ReturnStatement::toIR(IRState* p)
emit_finallyblocks(p, enclosingtryfinally, NULL);
if (gIR->func()->inVolatile) {
// store-load barrier
DtoMemoryBarrier(false, false, true, false);
}
if (global.params.symdebug) DtoDwarfFuncEnd(f->decl);
new llvm::ReturnInst(p->scopebb());
llvm::ReturnInst::Create(p->scopebb());
}
else {
@@ -112,8 +117,13 @@ void ReturnStatement::toIR(IRState* p)
emit_finallyblocks(p, enclosingtryfinally, NULL);
if (gIR->func()->inVolatile) {
// store-load barrier
DtoMemoryBarrier(false, false, true, false);
}
if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
new llvm::ReturnInst(v, p->scopebb());
llvm::ReturnInst::Create(v, p->scopebb());
}
}
else
@@ -121,8 +131,13 @@ void ReturnStatement::toIR(IRState* p)
if (p->topfunc()->getReturnType() == llvm::Type::VoidTy) {
emit_finallyblocks(p, enclosingtryfinally, NULL);
if (gIR->func()->inVolatile) {
// store-load barrier
DtoMemoryBarrier(false, false, true, false);
}
if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
new llvm::ReturnInst(p->scopebb());
llvm::ReturnInst::Create(p->scopebb());
}
else {
assert(0); // why should this ever happen?
@@ -173,15 +188,15 @@ void IfStatement::toIR(IRState* p)
llvm::BasicBlock* oldend = gIR->scopeend();
llvm::BasicBlock* ifbb = new llvm::BasicBlock("if", gIR->topfunc(), oldend);
llvm::BasicBlock* endbb = new llvm::BasicBlock("endif", gIR->topfunc(), oldend);
llvm::BasicBlock* elsebb = elsebody ? new llvm::BasicBlock("else", gIR->topfunc(), endbb) : endbb;
llvm::BasicBlock* ifbb = llvm::BasicBlock::Create("if", gIR->topfunc(), oldend);
llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endif", gIR->topfunc(), oldend);
llvm::BasicBlock* elsebb = elsebody ? llvm::BasicBlock::Create("else", gIR->topfunc(), endbb) : endbb;
if (cond_val->getType() != llvm::Type::Int1Ty) {
Logger::cout() << "if conditional: " << *cond_val << '\n';
cond_val = DtoBoolean(cond_val);
}
llvm::Value* ifgoback = new llvm::BranchInst(ifbb, elsebb, cond_val, gIR->scopebb());
llvm::Value* ifgoback = llvm::BranchInst::Create(ifbb, elsebb, cond_val, gIR->scopebb());
// replace current scope
gIR->scope() = IRScope(ifbb,elsebb);
@@ -189,7 +204,7 @@ void IfStatement::toIR(IRState* p)
// do scoped statements
ifbody->toIR(p);
if (!gIR->scopereturned()) {
new llvm::BranchInst(endbb,gIR->scopebb());
llvm::BranchInst::Create(endbb,gIR->scopebb());
}
if (elsebody) {
@@ -197,7 +212,7 @@ void IfStatement::toIR(IRState* p)
gIR->scope() = IRScope(elsebb,endbb);
elsebody->toIR(p);
if (!gIR->scopereturned()) {
new llvm::BranchInst(endbb,gIR->scopebb());
llvm::BranchInst::Create(endbb,gIR->scopebb());
}
}
@@ -223,10 +238,10 @@ void ScopeStatement::toIR(IRState* p)
}
else {
assert(!p->scopereturned());
beginbb = new llvm::BasicBlock("scope", p->topfunc(), oldend);
new llvm::BranchInst(beginbb, p->scopebb());
beginbb = llvm::BasicBlock::Create("scope", p->topfunc(), oldend);
llvm::BranchInst::Create(beginbb, p->scopebb());
}
llvm::BasicBlock* endbb = new llvm::BasicBlock("endscope", p->topfunc(), oldend);
llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endscope", p->topfunc(), oldend);
gIR->scope() = IRScope(beginbb, endbb);
@@ -246,13 +261,13 @@ void WhileStatement::toIR(IRState* p)
// create while blocks
llvm::BasicBlock* oldend = gIR->scopeend();
llvm::BasicBlock* whilebb = new llvm::BasicBlock("whilecond", gIR->topfunc(), oldend);
llvm::BasicBlock* whilebodybb = new llvm::BasicBlock("whilebody", gIR->topfunc(), oldend);
llvm::BasicBlock* endbb = new llvm::BasicBlock("endwhile", gIR->topfunc(), oldend);
llvm::BasicBlock* whilebb = llvm::BasicBlock::Create("whilecond", gIR->topfunc(), oldend);
llvm::BasicBlock* whilebodybb = llvm::BasicBlock::Create("whilebody", gIR->topfunc(), oldend);
llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endwhile", gIR->topfunc(), oldend);
// move into the while block
p->ir->CreateBr(whilebb);
//new llvm::BranchInst(whilebb, gIR->scopebb());
//llvm::BranchInst::Create(whilebb, gIR->scopebb());
// replace current scope
gIR->scope() = IRScope(whilebb,endbb);
@@ -263,7 +278,7 @@ void WhileStatement::toIR(IRState* p)
delete cond_e;
// conditional branch
llvm::Value* ifbreak = new llvm::BranchInst(whilebodybb, endbb, cond_val, p->scopebb());
llvm::Value* ifbreak = llvm::BranchInst::Create(whilebodybb, endbb, cond_val, p->scopebb());
// rewrite scope
gIR->scope() = IRScope(whilebodybb,endbb);
@@ -275,7 +290,7 @@ void WhileStatement::toIR(IRState* p)
// loop
if (!gIR->scopereturned())
new llvm::BranchInst(whilebb, gIR->scopebb());
llvm::BranchInst::Create(whilebb, gIR->scopebb());
// rewrite the scope
gIR->scope() = IRScope(endbb,oldend);
@@ -290,12 +305,12 @@ void DoStatement::toIR(IRState* p)
// create while blocks
llvm::BasicBlock* oldend = gIR->scopeend();
llvm::BasicBlock* dowhilebb = new llvm::BasicBlock("dowhile", gIR->topfunc(), oldend);
llvm::BasicBlock* endbb = new llvm::BasicBlock("enddowhile", gIR->topfunc(), oldend);
llvm::BasicBlock* dowhilebb = llvm::BasicBlock::Create("dowhile", gIR->topfunc(), oldend);
llvm::BasicBlock* endbb = llvm::BasicBlock::Create("enddowhile", gIR->topfunc(), oldend);
// move into the while block
assert(!gIR->scopereturned());
new llvm::BranchInst(dowhilebb, gIR->scopebb());
llvm::BranchInst::Create(dowhilebb, gIR->scopebb());
// replace current scope
gIR->scope() = IRScope(dowhilebb,endbb);
@@ -311,7 +326,7 @@ void DoStatement::toIR(IRState* p)
delete cond_e;
// conditional branch
llvm::Value* ifbreak = new llvm::BranchInst(dowhilebb, endbb, cond_val, gIR->scopebb());
llvm::Value* ifbreak = llvm::BranchInst::Create(dowhilebb, endbb, cond_val, gIR->scopebb());
// rewrite the scope
gIR->scope() = IRScope(endbb,oldend);
@@ -326,10 +341,10 @@ void ForStatement::toIR(IRState* p)
// create for blocks
llvm::BasicBlock* oldend = gIR->scopeend();
llvm::BasicBlock* forbb = new llvm::BasicBlock("forcond", gIR->topfunc(), oldend);
llvm::BasicBlock* forbodybb = new llvm::BasicBlock("forbody", gIR->topfunc(), oldend);
llvm::BasicBlock* forincbb = new llvm::BasicBlock("forinc", gIR->topfunc(), oldend);
llvm::BasicBlock* endbb = new llvm::BasicBlock("endfor", gIR->topfunc(), oldend);
llvm::BasicBlock* forbb = llvm::BasicBlock::Create("forcond", gIR->topfunc(), oldend);
llvm::BasicBlock* forbodybb = llvm::BasicBlock::Create("forbody", gIR->topfunc(), oldend);
llvm::BasicBlock* forincbb = llvm::BasicBlock::Create("forinc", gIR->topfunc(), oldend);
llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endfor", gIR->topfunc(), oldend);
// init
if (init != 0)
@@ -337,7 +352,7 @@ void ForStatement::toIR(IRState* p)
// move into the for condition block, ie. start the loop
assert(!gIR->scopereturned());
new llvm::BranchInst(forbb, gIR->scopebb());
llvm::BranchInst::Create(forbb, gIR->scopebb());
p->loopbbs.push_back(IRLoopScope(this,enclosingtryfinally,forincbb,endbb));
@@ -351,7 +366,7 @@ void ForStatement::toIR(IRState* p)
// conditional branch
assert(!gIR->scopereturned());
new llvm::BranchInst(forbodybb, endbb, cond_val, gIR->scopebb());
llvm::BranchInst::Create(forbodybb, endbb, cond_val, gIR->scopebb());
// rewrite scope
gIR->scope() = IRScope(forbodybb,forincbb);
@@ -361,7 +376,7 @@ void ForStatement::toIR(IRState* p)
// move into the for increment block
if (!gIR->scopereturned())
new llvm::BranchInst(forincbb, gIR->scopebb());
llvm::BranchInst::Create(forincbb, gIR->scopebb());
gIR->scope() = IRScope(forincbb, endbb);
// increment
@@ -372,7 +387,7 @@ void ForStatement::toIR(IRState* p)
// loop
if (!gIR->scopereturned())
new llvm::BranchInst(forbb, gIR->scopebb());
llvm::BranchInst::Create(forbb, gIR->scopebb());
p->loopbbs.pop_back();
@@ -402,7 +417,7 @@ void BreakStatement::toIR(IRState* p)
IRState::LoopScopeVec::reverse_iterator it;
for(it = gIR->loopbbs.rbegin(); it != gIR->loopbbs.rend(); ++it) {
if(it->s == targetLoopStatement) {
new llvm::BranchInst(it->end, gIR->scopebb());
llvm::BranchInst::Create(it->end, gIR->scopebb());
return;
}
}
@@ -410,7 +425,7 @@ void BreakStatement::toIR(IRState* p)
}
else {
emit_finallyblocks(p, enclosingtryfinally, gIR->loopbbs.back().enclosingtryfinally);
new llvm::BranchInst(gIR->loopbbs.back().end, gIR->scopebb());
llvm::BranchInst::Create(gIR->loopbbs.back().end, gIR->scopebb());
}
}
@@ -436,7 +451,7 @@ void ContinueStatement::toIR(IRState* p)
IRState::LoopScopeVec::reverse_iterator it;
for(it = gIR->loopbbs.rbegin(); it != gIR->loopbbs.rend(); ++it) {
if(it->s == targetLoopStatement) {
new llvm::BranchInst(it->begin, gIR->scopebb());
llvm::BranchInst::Create(it->begin, gIR->scopebb());
return;
}
}
@@ -444,7 +459,7 @@ void ContinueStatement::toIR(IRState* p)
}
else {
emit_finallyblocks(p, enclosingtryfinally, gIR->loopbbs.back().enclosingtryfinally);
new llvm::BranchInst(gIR->loopbbs.back().begin, gIR->scopebb());
llvm::BranchInst::Create(gIR->loopbbs.back().begin, gIR->scopebb());
}
}
@@ -469,13 +484,13 @@ void TryFinallyStatement::toIR(IRState* p)
// create basic blocks
llvm::BasicBlock* oldend = p->scopeend();
llvm::BasicBlock* trybb = new llvm::BasicBlock("try", p->topfunc(), oldend);
llvm::BasicBlock* finallybb = new llvm::BasicBlock("finally", p->topfunc(), oldend);
llvm::BasicBlock* endbb = new llvm::BasicBlock("endtryfinally", p->topfunc(), oldend);
llvm::BasicBlock* trybb = llvm::BasicBlock::Create("try", p->topfunc(), oldend);
llvm::BasicBlock* finallybb = llvm::BasicBlock::Create("finally", p->topfunc(), oldend);
llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endtryfinally", p->topfunc(), oldend);
// pass the previous BB into this
assert(!gIR->scopereturned());
new llvm::BranchInst(trybb, p->scopebb());
llvm::BranchInst::Create(trybb, p->scopebb());
// do the try block
p->scope() = IRScope(trybb,finallybb);
@@ -485,7 +500,7 @@ void TryFinallyStatement::toIR(IRState* p)
// terminate try BB
if (!p->scopereturned())
new llvm::BranchInst(finallybb, p->scopebb());
llvm::BranchInst::Create(finallybb, p->scopebb());
// do finally block
p->scope() = IRScope(finallybb,endbb);
@@ -494,7 +509,7 @@ void TryFinallyStatement::toIR(IRState* p)
// terminate finally
if (!gIR->scopereturned()) {
new llvm::BranchInst(endbb, p->scopebb());
llvm::BranchInst::Create(endbb, p->scopebb());
}
// rewrite the scope
@@ -513,13 +528,13 @@ void TryCatchStatement::toIR(IRState* p)
// create basic blocks
llvm::BasicBlock* oldend = p->scopeend();
llvm::BasicBlock* trybb = new llvm::BasicBlock("try", p->topfunc(), oldend);
llvm::BasicBlock* catchbb = new llvm::BasicBlock("catch", p->topfunc(), oldend);
llvm::BasicBlock* endbb = new llvm::BasicBlock("endtrycatch", p->topfunc(), oldend);
llvm::BasicBlock* trybb = llvm::BasicBlock::Create("try", p->topfunc(), oldend);
llvm::BasicBlock* catchbb = llvm::BasicBlock::Create("catch", p->topfunc(), oldend);
llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endtrycatch", p->topfunc(), oldend);
// pass the previous BB into this
assert(!gIR->scopereturned());
new llvm::BranchInst(trybb, p->scopebb());
llvm::BranchInst::Create(trybb, p->scopebb());
// do the try block
p->scope() = IRScope(trybb,catchbb);
@@ -527,11 +542,11 @@ void TryCatchStatement::toIR(IRState* p)
body->toIR(p);
if (!gIR->scopereturned())
new llvm::BranchInst(endbb, p->scopebb());
llvm::BranchInst::Create(endbb, p->scopebb());
// do catch
p->scope() = IRScope(catchbb,oldend);
new llvm::BranchInst(endbb, p->scopebb());
llvm::BranchInst::Create(endbb, p->scopebb());
/*assert(catches);
for(size_t i=0; i<catches->dim; ++i)
{
@@ -643,7 +658,7 @@ void SwitchStatement::toIR(IRState* p)
CaseStatement* cs = (CaseStatement*)cases->data[i];
std::string lblname("case");
llvm::BasicBlock* bb = new llvm::BasicBlock(lblname, p->topfunc(), oldend);
llvm::BasicBlock* bb = llvm::BasicBlock::Create(lblname, p->topfunc(), oldend);
cs->bodyBB = bb;
std::vector<llvm::ConstantInt*> tmp;
@@ -711,12 +726,12 @@ void SwitchStatement::toIR(IRState* p)
// default
llvm::BasicBlock* defbb = 0;
if (!hasNoDefault) {
defbb = new llvm::BasicBlock("default", p->topfunc(), oldend);
defbb = llvm::BasicBlock::Create("default", p->topfunc(), oldend);
sdefault->bodyBB = defbb;
}
// end (break point)
llvm::BasicBlock* endbb = new llvm::BasicBlock("switchend", p->topfunc(), oldend);
llvm::BasicBlock* endbb = llvm::BasicBlock::Create("switchend", p->topfunc(), oldend);
// condition var
llvm::Value* condVal;
@@ -729,7 +744,7 @@ void SwitchStatement::toIR(IRState* p)
else {
condVal = call_string_switch_runtime(switchTable, condition);
}
llvm::SwitchInst* si = new llvm::SwitchInst(condVal, defbb ? defbb : endbb, cases->dim, p->scopebb());
llvm::SwitchInst* si = llvm::SwitchInst::Create(condVal, defbb ? defbb : endbb, cases->dim, p->scopebb());
// add the cases
size_t n = vcases.size();
@@ -754,7 +769,7 @@ void SwitchStatement::toIR(IRState* p)
llvm::BasicBlock* curbb = p->scopebb();
if (curbb->empty() || !curbb->back().isTerminator())
{
new llvm::BranchInst(nextbb, curbb);
llvm::BranchInst::Create(nextbb, curbb);
}
}
@@ -770,7 +785,7 @@ void SwitchStatement::toIR(IRState* p)
llvm::BasicBlock* curbb = p->scopebb();
if (curbb->empty() || !curbb->back().isTerminator())
{
new llvm::BranchInst(endbb, curbb);
llvm::BranchInst::Create(endbb, curbb);
}
}
@@ -794,7 +809,7 @@ void UnrolledLoopStatement::toIR(IRState* p)
LOG_SCOPE;
llvm::BasicBlock* oldend = gIR->scopeend();
llvm::BasicBlock* endbb = new llvm::BasicBlock("unrolledend", p->topfunc(), oldend);
llvm::BasicBlock* endbb = llvm::BasicBlock::Create("unrolledend", p->topfunc(), oldend);
p->scope() = IRScope(p->scopebb(),endbb);
p->loopbbs.push_back(IRLoopScope(this,enclosingtryfinally,p->scopebb(),endbb));
@@ -807,7 +822,7 @@ void UnrolledLoopStatement::toIR(IRState* p)
p->loopbbs.pop_back();
new llvm::BranchInst(endbb, p->scopebb());
llvm::BranchInst::Create(endbb, p->scopebb());
p->scope() = IRScope(endbb,oldend);
}
@@ -916,12 +931,12 @@ void ForeachStatement::toIR(IRState* p)
}
llvm::BasicBlock* oldend = gIR->scopeend();
llvm::BasicBlock* condbb = new llvm::BasicBlock("foreachcond", p->topfunc(), oldend);
llvm::BasicBlock* bodybb = new llvm::BasicBlock("foreachbody", p->topfunc(), oldend);
llvm::BasicBlock* nextbb = new llvm::BasicBlock("foreachnext", p->topfunc(), oldend);
llvm::BasicBlock* endbb = new llvm::BasicBlock("foreachend", p->topfunc(), oldend);
llvm::BasicBlock* condbb = llvm::BasicBlock::Create("foreachcond", p->topfunc(), oldend);
llvm::BasicBlock* bodybb = llvm::BasicBlock::Create("foreachbody", p->topfunc(), oldend);
llvm::BasicBlock* nextbb = llvm::BasicBlock::Create("foreachnext", p->topfunc(), oldend);
llvm::BasicBlock* endbb = llvm::BasicBlock::Create("foreachend", p->topfunc(), oldend);
new llvm::BranchInst(condbb, p->scopebb());
llvm::BranchInst::Create(condbb, p->scopebb());
// condition
p->scope() = IRScope(condbb,bodybb);
@@ -936,7 +951,7 @@ void ForeachStatement::toIR(IRState* p)
load = llvm::BinaryOperator::createSub(load,llvm::ConstantInt::get(keytype, 1, false),"tmp",p->scopebb());
new llvm::StoreInst(load, keyvar, p->scopebb());
}
new llvm::BranchInst(bodybb, endbb, done, p->scopebb());
llvm::BranchInst::Create(bodybb, endbb, done, p->scopebb());
// init body
p->scope() = IRScope(bodybb,nextbb);
@@ -947,7 +962,7 @@ void ForeachStatement::toIR(IRState* p)
if (aggrtype->ty == Tsarray)
value->ir.irLocal->value = DtoGEP(val,zero,loadedKey,"tmp");
else if (aggrtype->ty == Tarray)
value->ir.irLocal->value = new llvm::GetElementPtrInst(val,loadedKey,"tmp",p->scopebb());
value->ir.irLocal->value = llvm::GetElementPtrInst::Create(val,loadedKey,"tmp",p->scopebb());
if (!value->isRef() && !value->isOut()) {
DValue* dst = new DVarValue(value->type, valvar, true);
@@ -962,7 +977,7 @@ void ForeachStatement::toIR(IRState* p)
p->loopbbs.pop_back();
if (!p->scopereturned())
new llvm::BranchInst(nextbb, p->scopebb());
llvm::BranchInst::Create(nextbb, p->scopebb());
// next
p->scope() = IRScope(nextbb,endbb);
@@ -971,7 +986,7 @@ void ForeachStatement::toIR(IRState* p)
load = p->ir->CreateAdd(load, llvm::ConstantInt::get(keytype, 1, false), "tmp");
DtoStore(load, keyvar);
}
new llvm::BranchInst(condbb, p->scopebb());
llvm::BranchInst::Create(condbb, p->scopebb());
// end
p->scope() = IRScope(endbb,oldend);
@@ -990,10 +1005,10 @@ void LabelStatement::toIR(IRState* p)
if (llvmBB)
llvmBB->moveBefore(oldend);
else
llvmBB = new llvm::BasicBlock("label", p->topfunc(), oldend);
llvmBB = llvm::BasicBlock::Create("label", p->topfunc(), oldend);
if (!p->scopereturned())
new llvm::BranchInst(llvmBB, p->scopebb());
llvm::BranchInst::Create(llvmBB, p->scopebb());
p->scope() = IRScope(llvmBB,oldend);
if (statement)
@@ -1010,10 +1025,10 @@ void GotoStatement::toIR(IRState* p)
assert(tf == NULL);
llvm::BasicBlock* oldend = gIR->scopeend();
llvm::BasicBlock* bb = new llvm::BasicBlock("aftergoto", p->topfunc(), oldend);
llvm::BasicBlock* bb = llvm::BasicBlock::Create("aftergoto", p->topfunc(), oldend);
if (label->statement->llvmBB == NULL)
label->statement->llvmBB = new llvm::BasicBlock("label", p->topfunc());
label->statement->llvmBB = llvm::BasicBlock::Create("label", p->topfunc());
assert(!p->scopereturned());
// find finallys between goto and label
@@ -1029,7 +1044,7 @@ void GotoStatement::toIR(IRState* p)
// emit code for finallys between goto and label
emit_finallyblocks(p, enclosingtryfinally, endfinally);
new llvm::BranchInst(label->statement->llvmBB, p->scopebb());
llvm::BranchInst::Create(label->statement->llvmBB, p->scopebb());
p->scope() = IRScope(bb,oldend);
}
@@ -1041,14 +1056,14 @@ void GotoDefaultStatement::toIR(IRState* p)
LOG_SCOPE;
llvm::BasicBlock* oldend = gIR->scopeend();
llvm::BasicBlock* bb = new llvm::BasicBlock("aftergotodefault", p->topfunc(), oldend);
llvm::BasicBlock* bb = llvm::BasicBlock::Create("aftergotodefault", p->topfunc(), oldend);
assert(!p->scopereturned());
assert(sw->sdefault->bodyBB);
emit_finallyblocks(p, enclosingtryfinally, sw->enclosingtryfinally);
new llvm::BranchInst(sw->sdefault->bodyBB, p->scopebb());
llvm::BranchInst::Create(sw->sdefault->bodyBB, p->scopebb());
p->scope() = IRScope(bb,oldend);
}
@@ -1060,14 +1075,14 @@ void GotoCaseStatement::toIR(IRState* p)
LOG_SCOPE;
llvm::BasicBlock* oldend = gIR->scopeend();
llvm::BasicBlock* bb = new llvm::BasicBlock("aftergotocase", p->topfunc(), oldend);
llvm::BasicBlock* bb = llvm::BasicBlock::Create("aftergotocase", p->topfunc(), oldend);
assert(!p->scopereturned());
assert(cs->bodyBB);
emit_finallyblocks(p, enclosingtryfinally, sw->enclosingtryfinally);
new llvm::BranchInst(cs->bodyBB, p->scopebb());
llvm::BranchInst::Create(cs->bodyBB, p->scopebb());
p->scope() = IRScope(bb,oldend);
}
@@ -1144,7 +1159,35 @@ void VolatileStatement::toIR(IRState* p)
Logger::attention(loc, "volatile is currently ignored. only the body will be emitted");
statement->toIR(p);
// mark in volate
bool old = gIR->func()->inVolatile;
gIR->func()->inVolatile = true;
// has statement
if (statement != NULL)
{
// load-store
DtoMemoryBarrier(false, true, false, false);
// do statement
statement->toIR(p);
// not point in a unreachable barrier, terminating statements should insert this themselves.
if (statement->fallOffEnd())
{
// store-load
DtoMemoryBarrier(false, false, true, false);
}
}
// barrier only
else
{
// load-store & store-load
DtoMemoryBarrier(false, true, true, false);
}
// restore volatile state
gIR->func()->inVolatile = old;
}
//////////////////////////////////////////////////////////////////////////////

10
gen/structs.cpp
View File

@@ -43,7 +43,7 @@ llvm::Value* DtoStructZeroInit(llvm::Value* v)
llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false);
llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
llvm::Value* ret = new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
llvm::Value* ret = llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
return ret;
}
@@ -71,7 +71,7 @@ llvm::Value* DtoStructCopy(llvm::Value* dst, llvm::Value* src)
llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false);
llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
return new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
return llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
@@ -130,7 +130,7 @@ llvm::Value* DtoIndexStruct(llvm::Value* ptr, StructDeclaration* sd, Type* t, un
if (ptr->getType() != llt)
ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp");
if (vd->ir.irField->indexOffset)
ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
ptr = llvm::GetElementPtrInst::Create(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
return ptr;
}
else if (vdtype->ty == Tstruct && (vd->offset + vdtype->size()) > os) {
@@ -142,7 +142,7 @@ llvm::Value* DtoIndexStruct(llvm::Value* ptr, StructDeclaration* sd, Type* t, un
ptr = DtoGEP(ptr, idxs, "tmp");
if (ptr->getType() != llt)
ptr = DtoBitCast(ptr, llt);
ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
ptr = llvm::GetElementPtrInst::Create(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
std::vector<unsigned> tmp;
return DtoIndexStruct(ptr, ssd, t, os-vd->offset, tmp);
}
@@ -163,7 +163,7 @@ llvm::Value* DtoIndexStruct(llvm::Value* ptr, StructDeclaration* sd, Type* t, un
size_t llt_sz = getTypeStoreSize(llt->getContainedType(0));
assert(os % llt_sz == 0);
ptr = DtoBitCast(ptr, llt);
return new llvm::GetElementPtrInst(ptr, DtoConstUint(os / llt_sz), "tmp", gIR->scopebb());
return llvm::GetElementPtrInst::Create(ptr, DtoConstUint(os / llt_sz), "tmp", gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////

70
gen/toir.cpp
View File

@@ -631,7 +631,7 @@ DValue* AddExp::toElem(IRState* p)
return new DImValue(type, l->getRVal());
}
}
llvm::Value* v = new llvm::GetElementPtrInst(l->getRVal(), r->getRVal(), "tmp", p->scopebb());
llvm::Value* v = llvm::GetElementPtrInst::Create(l->getRVal(), r->getRVal(), "tmp", p->scopebb());
return new DImValue(type, v);
}
else if (t->iscomplex()) {
@@ -663,7 +663,7 @@ DValue* AddAssignExp::toElem(IRState* p)
DValue* res;
if (DtoDType(e1->type)->ty == Tpointer) {
llvm::Value* gep = new llvm::GetElementPtrInst(l->getRVal(),r->getRVal(),"tmp",p->scopebb());
llvm::Value* gep = llvm::GetElementPtrInst::Create(l->getRVal(),r->getRVal(),"tmp",p->scopebb());
res = new DImValue(type, gep);
}
else if (t->iscomplex()) {
@@ -713,7 +713,7 @@ DValue* MinExp::toElem(IRState* p)
}
else if (t1->ty == Tpointer) {
llvm::Value* idx = p->ir->CreateNeg(r->getRVal(), "tmp");
llvm::Value* v = new llvm::GetElementPtrInst(l->getRVal(), idx, "tmp", p->scopebb());
llvm::Value* v = llvm::GetElementPtrInst::Create(l->getRVal(), idx, "tmp", p->scopebb());
return new DImValue(type, v);
}
else if (t->iscomplex()) {
@@ -742,7 +742,7 @@ DValue* MinAssignExp::toElem(IRState* p)
llvm::Value* tmp = r->getRVal();
llvm::Value* zero = llvm::ConstantInt::get(tmp->getType(),0,false);
tmp = llvm::BinaryOperator::createSub(zero,tmp,"tmp",p->scopebb());
tmp = new llvm::GetElementPtrInst(l->getRVal(),tmp,"tmp",p->scopebb());
tmp = llvm::GetElementPtrInst::Create(l->getRVal(),tmp,"tmp",p->scopebb());
res = new DImValue(type, tmp);
}
else if (t->iscomplex()) {
@@ -1204,7 +1204,7 @@ DValue* CallExp::toElem(IRState* p)
//Logger::cout() << "Calling: " << *funcval << '\n';
// call the function
llvm::CallInst* call = new llvm::CallInst(funcval, llargs.begin(), llargs.end(), varname, p->scopebb());
llvm::CallInst* call = llvm::CallInst::Create(funcval, llargs.begin(), llargs.end(), varname, p->scopebb());
llvm::Value* retllval = (retinptr) ? llargs[0] : call;
if (retinptr && dfn && dfn->func && dfn->func->runTimeHack) {
@@ -1548,7 +1548,7 @@ DValue* IndexExp::toElem(IRState* p)
llvm::Value* arrptr = 0;
if (e1type->ty == Tpointer) {
arrptr = new llvm::GetElementPtrInst(l->getRVal(),r->getRVal(),"tmp",p->scopebb());
arrptr = llvm::GetElementPtrInst::Create(l->getRVal(),r->getRVal(),"tmp",p->scopebb());
}
else if (e1type->ty == Tsarray) {
arrptr = DtoGEP(l->getRVal(), zero, r->getRVal(),"tmp",p->scopebb());
@@ -1556,7 +1556,7 @@ DValue* IndexExp::toElem(IRState* p)
else if (e1type->ty == Tarray) {
arrptr = DtoGEP(l->getRVal(),zero,one,"tmp",p->scopebb());
arrptr = new llvm::LoadInst(arrptr,"tmp",p->scopebb());
arrptr = new llvm::GetElementPtrInst(arrptr,r->getRVal(),"tmp",p->scopebb());
arrptr = llvm::GetElementPtrInst::Create(arrptr,r->getRVal(),"tmp",p->scopebb());
}
else if (e1type->ty == Taarray) {
return DtoAAIndex(type, l, r);
@@ -1615,7 +1615,7 @@ DValue* SliceExp::toElem(IRState* p)
llvm::ConstantInt* c = llvm::cast<llvm::ConstantInt>(cv->c);
if (!(lwr_is_zero = c->isZero())) {
emem = new llvm::GetElementPtrInst(emem,cv->c,"tmp",p->scopebb());
emem = llvm::GetElementPtrInst::Create(emem,cv->c,"tmp",p->scopebb());
}
}
else
@@ -1623,13 +1623,13 @@ DValue* SliceExp::toElem(IRState* p)
if (e1type->ty == Tarray) {
llvm::Value* tmp = DtoGEP(vmem,zero,one,"tmp",p->scopebb());
tmp = new llvm::LoadInst(tmp,"tmp",p->scopebb());
emem = new llvm::GetElementPtrInst(tmp,lo->getRVal(),"tmp",p->scopebb());
emem = llvm::GetElementPtrInst::Create(tmp,lo->getRVal(),"tmp",p->scopebb());
}
else if (e1type->ty == Tsarray) {
emem = DtoGEP(vmem,zero,lo->getRVal(),"tmp",p->scopebb());
}
else if (e1type->ty == Tpointer) {
emem = new llvm::GetElementPtrInst(v->getRVal(),lo->getRVal(),"tmp",p->scopebb());
emem = llvm::GetElementPtrInst::Create(v->getRVal(),lo->getRVal(),"tmp",p->scopebb());
}
else {
Logger::println("type = %s", e1type->toChars());
@@ -1903,12 +1903,12 @@ DValue* PostExp::toElem(IRState* p)
llvm::Constant* minusone = llvm::ConstantInt::get(DtoSize_t(),(uint64_t)-1,true);
llvm::Constant* plusone = llvm::ConstantInt::get(DtoSize_t(),(uint64_t)1,false);
llvm::Constant* whichone = (op == TOKplusplus) ? plusone : minusone;
post = new llvm::GetElementPtrInst(val, whichone, "tmp", p->scopebb());
post = llvm::GetElementPtrInst::Create(val, whichone, "tmp", p->scopebb());
}
else if (e1type->isfloating())
{
assert(e2type->isfloating());
llvm::Value* one = llvm::ConstantFP::get(val->getType(), llvm::APFloat(1.0f));
llvm::Value* one = DtoConstFP(e1type, 1.0);
if (op == TOKplusplus) {
post = llvm::BinaryOperator::createAdd(val,one,"tmp",p->scopebb());
}
@@ -2140,22 +2140,22 @@ DValue* AssertExp::toElem(IRState* p)
// create basic blocks
llvm::BasicBlock* oldend = p->scopeend();
llvm::BasicBlock* assertbb = new llvm::BasicBlock("assert", p->topfunc(), oldend);
llvm::BasicBlock* endbb = new llvm::BasicBlock("endassert", p->topfunc(), oldend);
llvm::BasicBlock* assertbb = llvm::BasicBlock::Create("assert", p->topfunc(), oldend);
llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endassert", p->topfunc(), oldend);
// test condition
llvm::Value* condval = cond->getRVal();
condval = DtoBoolean(condval);
// branch
new llvm::BranchInst(endbb, assertbb, condval, p->scopebb());
llvm::BranchInst::Create(endbb, assertbb, condval, p->scopebb());
// call assert runtime functions
p->scope() = IRScope(assertbb,endbb);
DtoAssert(&loc, msg ? msg->toElem(p) : NULL);
if (!gIR->scopereturned())
new llvm::BranchInst(endbb, p->scopebb());
llvm::BranchInst::Create(endbb, p->scopebb());
// rewrite the scope
p->scope() = IRScope(endbb,oldend);
@@ -2196,12 +2196,12 @@ DValue* AndAndExp::toElem(IRState* p)
DValue* u = e1->toElem(p);
llvm::BasicBlock* oldend = p->scopeend();
llvm::BasicBlock* andand = new llvm::BasicBlock("andand", gIR->topfunc(), oldend);
llvm::BasicBlock* andandend = new llvm::BasicBlock("andandend", gIR->topfunc(), oldend);
llvm::BasicBlock* andand = llvm::BasicBlock::Create("andand", gIR->topfunc(), oldend);
llvm::BasicBlock* andandend = llvm::BasicBlock::Create("andandend", gIR->topfunc(), oldend);
llvm::Value* ubool = DtoBoolean(u->getRVal());
new llvm::StoreInst(ubool,resval,p->scopebb());
new llvm::BranchInst(andand,andandend,ubool,p->scopebb());
llvm::BranchInst::Create(andand,andandend,ubool,p->scopebb());
p->scope() = IRScope(andand, andandend);
DValue* v = e2->toElem(p);
@@ -2209,7 +2209,7 @@ DValue* AndAndExp::toElem(IRState* p)
llvm::Value* vbool = DtoBoolean(v->getRVal());
llvm::Value* uandvbool = llvm::BinaryOperator::create(llvm::BinaryOperator::And, ubool, vbool,"tmp",p->scopebb());
new llvm::StoreInst(uandvbool,resval,p->scopebb());
new llvm::BranchInst(andandend,p->scopebb());
llvm::BranchInst::Create(andandend,p->scopebb());
p->scope() = IRScope(andandend, oldend);
@@ -2232,19 +2232,19 @@ DValue* OrOrExp::toElem(IRState* p)
DValue* u = e1->toElem(p);
llvm::BasicBlock* oldend = p->scopeend();
llvm::BasicBlock* oror = new llvm::BasicBlock("oror", gIR->topfunc(), oldend);
llvm::BasicBlock* ororend = new llvm::BasicBlock("ororend", gIR->topfunc(), oldend);
llvm::BasicBlock* oror = llvm::BasicBlock::Create("oror", gIR->topfunc(), oldend);
llvm::BasicBlock* ororend = llvm::BasicBlock::Create("ororend", gIR->topfunc(), oldend);
llvm::Value* ubool = DtoBoolean(u->getRVal());
new llvm::StoreInst(ubool,resval,p->scopebb());
new llvm::BranchInst(ororend,oror,ubool,p->scopebb());
llvm::BranchInst::Create(ororend,oror,ubool,p->scopebb());
p->scope() = IRScope(oror, ororend);
DValue* v = e2->toElem(p);
llvm::Value* vbool = DtoBoolean(v->getRVal());
new llvm::StoreInst(vbool,resval,p->scopebb());
new llvm::BranchInst(ororend,p->scopebb());
llvm::BranchInst::Create(ororend,p->scopebb());
p->scope() = IRScope(ororend, oldend);
@@ -2463,23 +2463,23 @@ DValue* CondExp::toElem(IRState* p)
DVarValue* dvv = new DVarValue(type, resval, true);
llvm::BasicBlock* oldend = p->scopeend();
llvm::BasicBlock* condtrue = new llvm::BasicBlock("condtrue", gIR->topfunc(), oldend);
llvm::BasicBlock* condfalse = new llvm::BasicBlock("condfalse", gIR->topfunc(), oldend);
llvm::BasicBlock* condend = new llvm::BasicBlock("condend", gIR->topfunc(), oldend);
llvm::BasicBlock* condtrue = llvm::BasicBlock::Create("condtrue", gIR->topfunc(), oldend);
llvm::BasicBlock* condfalse = llvm::BasicBlock::Create("condfalse", gIR->topfunc(), oldend);
llvm::BasicBlock* condend = llvm::BasicBlock::Create("condend", gIR->topfunc(), oldend);
DValue* c = econd->toElem(p);
llvm::Value* cond_val = DtoBoolean(c->getRVal());
new llvm::BranchInst(condtrue,condfalse,cond_val,p->scopebb());
llvm::BranchInst::Create(condtrue,condfalse,cond_val,p->scopebb());
p->scope() = IRScope(condtrue, condfalse);
DValue* u = e1->toElem(p);
DtoAssign(dvv, u);
new llvm::BranchInst(condend,p->scopebb());
llvm::BranchInst::Create(condend,p->scopebb());
p->scope() = IRScope(condfalse, condend);
DValue* v = e2->toElem(p);
DtoAssign(dvv, v);
new llvm::BranchInst(condend,p->scopebb());
llvm::BranchInst::Create(condend,p->scopebb());
p->scope() = IRScope(condend, oldend);
return dvv;
@@ -2521,15 +2521,7 @@ DValue* NegExp::toElem(IRState* p)
if (t->isintegral())
zero = llvm::ConstantInt::get(val->getType(), 0, true);
else if (t->isfloating()) {
if (t->ty == Tfloat32 || t->ty == Timaginary32)
zero = llvm::ConstantFP::get(val->getType(), llvm::APFloat(0.0f));
else if (t->ty == Tfloat64 || t->ty == Tfloat80 || t->ty == Timaginary64 || t->ty == Timaginary80)
zero = llvm::ConstantFP::get(val->getType(), llvm::APFloat(0.0));
else
{
Logger::println("unhandled fp negation of type %s", t->toChars());
assert(0);
}
zero = DtoConstFP(type, 0.0);
}
else
assert(0);

65
gen/tollvm.cpp
View File

@@ -272,6 +272,38 @@ llvm::Function* LLVM_DeclareMemCpy64()
return gIR->llvm_DeclareMemCpy64;
}
// llvm.memory.barrier
static llvm::Function* LLVM_DeclareMemBarrier()
{
if (gIR->llvm_DeclareMemBarrier == 0) {
std::vector<const llvm::Type*> pvec;
pvec.push_back(llvm::Type::Int1Ty);
pvec.push_back(llvm::Type::Int1Ty);
pvec.push_back(llvm::Type::Int1Ty);
pvec.push_back(llvm::Type::Int1Ty);
pvec.push_back(llvm::Type::Int1Ty);
llvm::FunctionType* functype = llvm::FunctionType::get(llvm::Type::VoidTy, pvec, false);
gIR->llvm_DeclareMemBarrier = llvm::cast<llvm::Function>(gIR->module->getOrInsertFunction("llvm.memory.barrier", functype));
assert(gIR->llvm_DeclareMemBarrier != NULL);
}
return gIR->llvm_DeclareMemBarrier;
}
void DtoMemoryBarrier(bool ll, bool ls, bool sl, bool ss, bool device)
{
llvm::Function* fn = LLVM_DeclareMemBarrier();
assert(fn != NULL);
llvm::SmallVector<llvm::Value*, 5> llargs;
llargs.push_back(DtoConstBool(ll));
llargs.push_back(DtoConstBool(ls));
llargs.push_back(DtoConstBool(sl));
llargs.push_back(DtoConstBool(ss));
llargs.push_back(DtoConstBool(device));
llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
llvm::Value* DtoDelegateToNull(llvm::Value* v)
@@ -291,7 +323,7 @@ llvm::Value* DtoDelegateToNull(llvm::Value* v)
llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false);
llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
llvm::Value* ret = new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
llvm::Value* ret = llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
return ret;
}
@@ -318,7 +350,7 @@ llvm::Value* DtoDelegateCopy(llvm::Value* dst, llvm::Value* src)
llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false);
llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
return new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
return llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
@@ -616,7 +648,7 @@ llvm::Value* DtoGEP(llvm::Value* ptr, llvm::Value* i0, llvm::Value* i1, const st
v[0] = i0;
v[1] = i1;
Logger::cout() << "DtoGEP: " << *ptr << ", " << *i0 << ", " << *i1 << '\n';
return new llvm::GetElementPtrInst(ptr, v.begin(), v.end(), var, bb?bb:gIR->scopebb());
return llvm::GetElementPtrInst::Create(ptr, v.begin(), v.end(), var, bb?bb:gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
@@ -633,14 +665,14 @@ llvm::Value* DtoGEP(llvm::Value* ptr, const std::vector<unsigned>& src, const st
dst[i] = llvm::ConstantInt::get(llvm::Type::Int32Ty, src[i], false);
}
//ostr << '\n';*/
return new llvm::GetElementPtrInst(ptr, dst.begin(), dst.end(), var, bb?bb:gIR->scopebb());
return llvm::GetElementPtrInst::Create(ptr, dst.begin(), dst.end(), var, bb?bb:gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
llvm::Value* DtoGEPi(llvm::Value* ptr, unsigned i, const std::string& var, llvm::BasicBlock* bb)
{
return new llvm::GetElementPtrInst(ptr, llvm::ConstantInt::get(llvm::Type::Int32Ty, i, false), var, bb?bb:gIR->scopebb());
return llvm::GetElementPtrInst::Create(ptr, llvm::ConstantInt::get(llvm::Type::Int32Ty, i, false), var, bb?bb:gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
@@ -650,7 +682,7 @@ llvm::Value* DtoGEPi(llvm::Value* ptr, unsigned i0, unsigned i1, const std::stri
std::vector<llvm::Value*> v(2);
v[0] = llvm::ConstantInt::get(llvm::Type::Int32Ty, i0, false);
v[1] = llvm::ConstantInt::get(llvm::Type::Int32Ty, i1, false);
return new llvm::GetElementPtrInst(ptr, v.begin(), v.end(), var, bb?bb:gIR->scopebb());
return llvm::GetElementPtrInst::Create(ptr, v.begin(), v.end(), var, bb?bb:gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
@@ -704,7 +736,7 @@ void DtoAssert(Loc* loc, DValue* msg)
// call
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, fname);
llvm::CallInst* call = new llvm::CallInst(fn, args.begin(), args.end(), "", gIR->scopebb());
llvm::CallInst* call = llvm::CallInst::Create(fn, args.begin(), args.end(), "", gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
@@ -1234,9 +1266,9 @@ llvm::ConstantFP* DtoConstFP(Type* t, long double value)
{
TY ty = DtoDType(t)->ty;
if (ty == Tfloat32 || ty == Timaginary32)
return llvm::ConstantFP::get(llvm::Type::FloatTy, llvm::APFloat(float(value)));
return llvm::ConstantFP::get(llvm::APFloat(float(value)));
else if (ty == Tfloat64 || ty == Timaginary64 || ty == Tfloat80 || ty == Timaginary80)
return llvm::ConstantFP::get(llvm::Type::DoubleTy, llvm::APFloat(double(value)));
return llvm::ConstantFP::get(llvm::APFloat(double(value)));
}
@@ -1288,7 +1320,7 @@ void DtoMemSetZero(llvm::Value* dst, llvm::Value* nbytes)
llargs[2] = nbytes;
llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
@@ -1317,19 +1349,22 @@ void DtoMemCpy(llvm::Value* dst, llvm::Value* src, llvm::Value* nbytes)
llargs[2] = nbytes;
llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
}
//////////////////////////////////////////////////////////////////////////////////////////
llvm::Value* DtoLoad(llvm::Value* src)
{
return gIR->ir->CreateLoad(src,"tmp");
llvm::Value* ld = gIR->ir->CreateLoad(src,"tmp");
//ld->setVolatile(gIR->func()->inVolatile);
return ld;
}
void DtoStore(llvm::Value* src, llvm::Value* dst)
{
gIR->ir->CreateStore(src,dst);
llvm::Value* st = gIR->ir->CreateStore(src,dst);
//st->setVolatile(gIR->func()->inVolatile);
}
bool DtoCanLoad(llvm::Value* ptr)
@@ -1460,8 +1495,8 @@ void DtoLazyStaticInit(bool istempl, llvm::Value* gvar, Initializer* init, Type*
// check flag and do init if not already done
llvm::BasicBlock* oldend = gIR->scopeend();
llvm::BasicBlock* initbb = new llvm::BasicBlock("ifnotinit",gIR->topfunc(),oldend);
llvm::BasicBlock* endinitbb = new llvm::BasicBlock("ifnotinitend",gIR->topfunc(),oldend);
llvm::BasicBlock* initbb = llvm::BasicBlock::Create("ifnotinit",gIR->topfunc(),oldend);
llvm::BasicBlock* endinitbb = llvm::BasicBlock::Create("ifnotinitend",gIR->topfunc(),oldend);
llvm::Value* cond = gIR->ir->CreateICmpEQ(gIR->ir->CreateLoad(gflag,"tmp"),DtoConstBool(false));
gIR->ir->CreateCondBr(cond, initbb, endinitbb);
gIR->scope() = IRScope(initbb,endinitbb);

1
gen/tollvm.h
View File

@@ -105,6 +105,7 @@ void DtoForceDefineDsymbol(Dsymbol* dsym);
// llvm wrappers
void DtoMemSetZero(llvm::Value* dst, llvm::Value* nbytes);
void DtoMemCpy(llvm::Value* dst, llvm::Value* src, llvm::Value* nbytes);
void DtoMemoryBarrier(bool ll, bool ls, bool sl, bool ss, bool device=false);
bool DtoCanLoad(llvm::Value* ptr);
llvm::Value* DtoLoad(llvm::Value* src);
void DtoStore(llvm::Value* src, llvm::Value* dst);

18
gen/toobj.cpp
View File

@@ -190,11 +190,11 @@ static llvm::Function* build_module_ctor()
std::vector<const llvm::Type*> argsTy;
const llvm::FunctionType* fnTy = llvm::FunctionType::get(llvm::Type::VoidTy,argsTy,false);
assert(gIR->module->getFunction(name) == NULL);
llvm::Function* fn = new llvm::Function(fnTy, llvm::GlobalValue::InternalLinkage, name, gIR->module);
llvm::Function* fn = llvm::Function::Create(fnTy, llvm::GlobalValue::InternalLinkage, name, gIR->module);
fn->setCallingConv(llvm::CallingConv::Fast);
llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn);
LLVMBuilder builder(bb);
llvm::BasicBlock* bb = llvm::BasicBlock::Create("entry", fn);
IRBuilder builder(bb);
for (size_t i=0; i<n; i++) {
llvm::Function* f = gIR->ctors[i]->ir.irFunc->func;
@@ -224,11 +224,11 @@ static llvm::Function* build_module_dtor()
std::vector<const llvm::Type*> argsTy;
const llvm::FunctionType* fnTy = llvm::FunctionType::get(llvm::Type::VoidTy,argsTy,false);
assert(gIR->module->getFunction(name) == NULL);
llvm::Function* fn = new llvm::Function(fnTy, llvm::GlobalValue::InternalLinkage, name, gIR->module);
llvm::Function* fn = llvm::Function::Create(fnTy, llvm::GlobalValue::InternalLinkage, name, gIR->module);
fn->setCallingConv(llvm::CallingConv::Fast);
llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn);
LLVMBuilder builder(bb);
llvm::BasicBlock* bb = llvm::BasicBlock::Create("entry", fn);
IRBuilder builder(bb);
for (size_t i=0; i<n; i++) {
llvm::Function* f = gIR->dtors[i]->ir.irFunc->func;
@@ -258,11 +258,11 @@ static llvm::Function* build_module_unittest()
std::vector<const llvm::Type*> argsTy;
const llvm::FunctionType* fnTy = llvm::FunctionType::get(llvm::Type::VoidTy,argsTy,false);
assert(gIR->module->getFunction(name) == NULL);
llvm::Function* fn = new llvm::Function(fnTy, llvm::GlobalValue::InternalLinkage, name, gIR->module);
llvm::Function* fn = llvm::Function::Create(fnTy, llvm::GlobalValue::InternalLinkage, name, gIR->module);
fn->setCallingConv(llvm::CallingConv::Fast);
llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn);
LLVMBuilder builder(bb);
llvm::BasicBlock* bb = llvm::BasicBlock::Create("entry", fn);
IRBuilder builder(bb);
for (size_t i=0; i<n; i++) {
llvm::Function* f = gIR->unitTests[i]->ir.irFunc->func;

1
ir/irfunction.cpp
View File

@@ -26,6 +26,7 @@ IrFunction::IrFunction(FuncDeclaration* fd)
dwarfSubProg = NULL;
srcfileArg = NULL;
inVolatile = false;
}
IrFunction::~IrFunction()

2
ir/irfunction.h
View File

@@ -24,6 +24,8 @@ struct IrFunction : IrBase
llvm::AllocaInst* srcfileArg;
bool inVolatile;
IrFunction(FuncDeclaration* fd);
virtual ~IrFunction();
};