mirrors/ldc
1
0
Fork 0
mirror of https://github.com/ldc-developers/ldc.git synced 2025-05-04 00:55:49 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add line number to error message of -nogc switch.

Browse source 
This was suggested by bearophile in the news group.
It also changes all Loc objects to be passed by reference.
This commit is contained in:
kai 2014-07-03 19:09:15 +02:00
parent e74e511b9c
commit 45fca1f3b5
23 changed files with 195 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

10
gen/aa.cpp
View file

@ -47,7 +47,7 @@ DValue* DtoAAIndex(Loc& loc, Type* type, DValue* aa, DValue* key, bool lvalue)
// extern(C) void* _aaInX(AA aa*, TypeInfo keyti, void* pkey)
// first get the runtime function
llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, lvalue?"_aaGetX":"_aaInX");
llvm::Function* func = LLVM_D_GetRuntimeFunction(loc, gIR->module, lvalue?"_aaGetX":"_aaInX");
LLFunctionType* funcTy = func->getFunctionType();
// aa param
@ -104,7 +104,7 @@ DValue* DtoAAIndex(Loc& loc, Type* type, DValue* aa, DValue* key, bool lvalue)
};
// call
llvm::Function* errorfn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_array_bounds");
llvm::Function* errorfn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_array_bounds");
gIR->CreateCallOrInvoke(errorfn, args);
// the function does not return
@ -129,7 +129,7 @@ DValue* DtoAAIn(Loc& loc, Type* type, DValue* aa, DValue* key)
// extern(C) void* _aaInX(AA aa*, TypeInfo keyti, void* pkey)
// first get the runtime function
llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, "_aaInX");
llvm::Function* func = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_aaInX");
LLFunctionType* funcTy = func->getFunctionType();
IF_LOG Logger::cout() << "_aaIn = " << *func << '\n';
@ -174,7 +174,7 @@ DValue *DtoAARemove(Loc& loc, DValue* aa, DValue* key)
// extern(C) bool _aaDelX(AA aa, TypeInfo keyti, void* pkey)
// first get the runtime function
llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, "_aaDelX");
llvm::Function* func = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_aaDelX");
LLFunctionType* funcTy = func->getFunctionType();
IF_LOG Logger::cout() << "_aaDel = " << *func << '\n';
@ -210,7 +210,7 @@ LLValue* DtoAAEquals(Loc& loc, TOK op, DValue* l, DValue* r)
{
Type* t = l->getType()->toBasetype();
assert(t == r->getType()->toBasetype() && "aa equality is only defined for aas of same type");
llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, "_aaEqual");
llvm::Function* func = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_aaEqual");
LLFunctionType* funcTy = func->getFunctionType();
LLValue* aaval = DtoBitCast(l->getRVal(), funcTy->getParamType(1));

64
gen/arrays.cpp
View file

@ -199,7 +199,7 @@ bool arrayNeedsPostblit(Type *t)
}
// Does array assignment (or initialization) from another array of the same element type.
void DtoArrayAssign(DValue *array, DValue *value, int op)
void DtoArrayAssign(Loc& loc, DValue *array, DValue *value, int op)
{
IF_LOG Logger::println("DtoArrayAssign");
LOG_SCOPE;
@ -213,7 +213,7 @@ void DtoArrayAssign(DValue *array, DValue *value, int op)
assert(t->nextOf());
Type *elemType = t->nextOf()->toBasetype();
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, op == TOKconstruct ? "_d_arrayctor" : "_d_arrayassign");
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, op == TOKconstruct ? "_d_arrayctor" : "_d_arrayassign");
LLValue* args[] = {
DtoTypeInfoOf(elemType),
DtoAggrPaint(DtoSlice(value), fn->getFunctionType()->getParamType(1)),
@ -226,7 +226,7 @@ void DtoArrayAssign(DValue *array, DValue *value, int op)
// If op is TOKconstruct, does construction of an array;
// otherwise, does assignment to an array.
void DtoArraySetAssign(Loc &loc, DValue *array, DValue *value, int op)
void DtoArraySetAssign(Loc& loc, DValue *array, DValue *value, int op)
{
IF_LOG Logger::println("DtoArraySetAssign");
LOG_SCOPE;
@ -237,7 +237,7 @@ void DtoArraySetAssign(Loc &loc, DValue *array, DValue *value, int op)
LLValue *ptr = DtoArrayPtr(array);
LLValue *len = DtoArrayLen(array);
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, op == TOKconstruct ? "_d_arraysetctor" : "_d_arraysetassign");
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, op == TOKconstruct ? "_d_arraysetctor" : "_d_arraysetassign");
LLValue* args[] = {
DtoBitCast(ptr, getVoidPtrType()),
DtoBitCast(makeLValue(loc, value), getVoidPtrType()),
@ -500,11 +500,11 @@ static LLValue* get_slice_ptr(DSliceValue* e, LLValue*& sz)
return DtoBitCast(e->ptr, getVoidPtrType());
}
static void copySlice(LLValue* dstarr, LLValue* sz1, LLValue* srcarr, LLValue* sz2)
static void copySlice(Loc& loc, LLValue* dstarr, LLValue* sz1, LLValue* srcarr, LLValue* sz2)
{
if (global.params.useAssert || gIR->emitArrayBoundsChecks())
{
LLValue* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_array_slice_copy");
LLValue* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_array_slice_copy");
gIR->CreateCallOrInvoke4(fn, dstarr, sz1, srcarr, sz2);
}
else
@ -516,7 +516,7 @@ static void copySlice(LLValue* dstarr, LLValue* sz1, LLValue* srcarr, LLValue* s
}
}
void DtoArrayCopySlices(DSliceValue* dst, DSliceValue* src)
void DtoArrayCopySlices(Loc& loc, DSliceValue* dst, DSliceValue* src)
{
IF_LOG Logger::println("ArrayCopySlices");
@ -524,10 +524,10 @@ void DtoArrayCopySlices(DSliceValue* dst, DSliceValue* src)
LLValue* dstarr = get_slice_ptr(dst,sz1);
LLValue* srcarr = get_slice_ptr(src,sz2);
copySlice(dstarr, sz1, srcarr, sz2);
copySlice(loc, dstarr, sz1, srcarr, sz2);
}
void DtoArrayCopyToSlice(DSliceValue* dst, DValue* src)
void DtoArrayCopyToSlice(Loc& loc, DSliceValue* dst, DValue* src)
{
IF_LOG Logger::println("ArrayCopyToSlice");
@ -538,7 +538,7 @@ void DtoArrayCopyToSlice(DSliceValue* dst, DValue* src)
LLType* arrayelemty = voidToI8(DtoType(src->getType()->nextOf()->toBasetype()));
LLValue* sz2 = gIR->ir->CreateMul(DtoConstSize_t(getTypePaddedSize(arrayelemty)), DtoArrayLen(src), "tmp");
copySlice(dstarr, sz1, srcarr, sz2);
copySlice(loc, dstarr, sz1, srcarr, sz2);
}
//////////////////////////////////////////////////////////////////////////////////////////
@ -618,7 +618,7 @@ DSliceValue* DtoNewDynArray(Loc& loc, Type* arrayType, DValue* dim, bool default
const char* fnname = defaultInit ?
(zeroInit ? "_d_newarrayT" : "_d_newarrayiT") :
"_d_newarrayvT";
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, fnname);
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, fnname);
// call allocator
LLValue* newArray = gIR->CreateCallOrInvoke2(fn, arrayTypeInfo, arrayLen, ".gc_mem").getInstruction();
@ -647,7 +647,7 @@ DSliceValue* DtoNewMulDimDynArray(Loc& loc, Type* arrayType, DValue** dims, size
const char* fnname = zeroInit ? "_d_newarraymT" : "_d_newarraymiT";
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, fnname);
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, fnname);
std::vector<LLValue*> args;
args.reserve(ndims+2);
@ -667,7 +667,7 @@ DSliceValue* DtoNewMulDimDynArray(Loc& loc, Type* arrayType, DValue** dims, size
}
//////////////////////////////////////////////////////////////////////////////////////////
DSliceValue* DtoResizeDynArray(Type* arrayType, DValue* array, LLValue* newdim)
DSliceValue* DtoResizeDynArray(Loc& loc, Type* arrayType, DValue* array, LLValue* newdim)
{
IF_LOG Logger::println("DtoResizeDynArray : %s", arrayType->toChars());
LOG_SCOPE;
@ -681,7 +681,7 @@ DSliceValue* DtoResizeDynArray(Type* arrayType, DValue* array, LLValue* newdim)
bool zeroInit = arrayType->toBasetype()->nextOf()->isZeroInit();
// call runtime
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, zeroInit ? "_d_arraysetlengthT" : "_d_arraysetlengthiT" );
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, zeroInit ? "_d_arraysetlengthT" : "_d_arraysetlengthiT" );
LLValue* args[] = {
DtoTypeInfoOf(arrayType),
@ -708,7 +708,7 @@ void DtoCatAssignElement(Loc& loc, Type* arrayType, DValue* array, Expression* e
// otherwise a ~= a[$-i] won't work correctly
DValue *expVal = exp->toElem(gIR);
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_arrayappendcTX");
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_arrayappendcTX");
LLValue* args[] = {
DtoTypeInfoOf(arrayType),
DtoBitCast(array->getLVal(), fn->getFunctionType()->getParamType(1)),
@ -726,14 +726,14 @@ void DtoCatAssignElement(Loc& loc, Type* arrayType, DValue* array, Expression* e
//////////////////////////////////////////////////////////////////////////////////////////
DSliceValue* DtoCatAssignArray(DValue* arr, Expression* exp)
DSliceValue* DtoCatAssignArray(Loc& loc, DValue* arr, Expression* exp)
{
IF_LOG Logger::println("DtoCatAssignArray");
LOG_SCOPE;
Type *arrayType = arr->getType();
// Prepare arguments
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_arrayappendT");
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_arrayappendT");
LLSmallVector<LLValue*,3> args;
// TypeInfo ti
args.push_back(DtoTypeInfoOf(arrayType));
@ -752,7 +752,7 @@ DSliceValue* DtoCatAssignArray(DValue* arr, Expression* exp)
//////////////////////////////////////////////////////////////////////////////////////////
DSliceValue* DtoCatArrays(Type* arrayType, Expression* exp1, Expression* exp2)
DSliceValue* DtoCatArrays(Loc& loc, Type* arrayType, Expression* exp1, Expression* exp2)
{
IF_LOG Logger::println("DtoCatAssignArray");
LOG_SCOPE;
@ -762,7 +762,7 @@ DSliceValue* DtoCatArrays(Type* arrayType, Expression* exp1, Expression* exp2)
if (exp1->op == TOKcat)
{ // handle multiple concat
fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_arraycatnT");
fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_arraycatnT");
args.push_back(DtoSlicePtr(exp2->toElem(gIR)));
CatExp *ce = static_cast<CatExp*>(exp1);
@ -782,7 +782,7 @@ DSliceValue* DtoCatArrays(Type* arrayType, Expression* exp1, Expression* exp2)
}
else
{
fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_arraycatT");
fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_arraycatT");
// TypeInfo ti
args.push_back(DtoTypeInfoOf(arrayType));
@ -802,13 +802,13 @@ DSliceValue* DtoCatArrays(Type* arrayType, Expression* exp1, Expression* exp2)
//////////////////////////////////////////////////////////////////////////////////////////
DSliceValue* DtoAppendDChar(DValue* arr, Expression* exp, const char *func)
DSliceValue* DtoAppendDChar(Loc& loc, DValue* arr, Expression* exp, const char *func)
{
Type *arrayType = arr->getType();
DValue* valueToAppend = exp->toElem(gIR);
// Prepare arguments
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, func);
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, func);
LLValue* args[] = {
// ref string x
DtoBitCast(arr->getLVal(), fn->getFunctionType()->getParamType(0)),
@ -824,20 +824,20 @@ DSliceValue* DtoAppendDChar(DValue* arr, Expression* exp, const char *func)
//////////////////////////////////////////////////////////////////////////////////////////
DSliceValue* DtoAppendDCharToString(DValue* arr, Expression* exp)
DSliceValue* DtoAppendDCharToString(Loc& loc, DValue* arr, Expression* exp)
{
IF_LOG Logger::println("DtoAppendDCharToString");
LOG_SCOPE;
return DtoAppendDChar(arr, exp, "_d_arrayappendcd");
return DtoAppendDChar(loc, arr, exp, "_d_arrayappendcd");
}
//////////////////////////////////////////////////////////////////////////////////////////
DSliceValue* DtoAppendDCharToUnicodeString(DValue* arr, Expression* exp)
DSliceValue* DtoAppendDCharToUnicodeString(Loc& loc, DValue* arr, Expression* exp)
{
IF_LOG Logger::println("DtoAppendDCharToUnicodeString");
LOG_SCOPE;
return DtoAppendDChar(arr, exp, "_d_arrayappendwd");
return DtoAppendDChar(loc, arr, exp, "_d_arrayappendwd");
}
//////////////////////////////////////////////////////////////////////////////////////////
@ -845,7 +845,7 @@ DSliceValue* DtoAppendDCharToUnicodeString(DValue* arr, Expression* exp)
static LLValue* DtoArrayEqCmp_impl(Loc& loc, const char* func, DValue* l, DValue* r, bool useti)
{
IF_LOG Logger::println("comparing arrays");
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, func);
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, func);
assert(fn);
// find common dynamic array type
@ -907,7 +907,7 @@ LLValue* DtoArrayCompare(Loc& loc, TOK op, DValue* l, DValue* r)
}
//////////////////////////////////////////////////////////////////////////////////////////
LLValue* DtoArrayCastLength(LLValue* len, LLType* elemty, LLType* newelemty)
LLValue* DtoArrayCastLength(Loc& loc, LLValue* len, LLType* elemty, LLType* newelemty)
{
IF_LOG Logger::println("DtoArrayCastLength");
LOG_SCOPE;
@ -927,7 +927,7 @@ LLValue* DtoArrayCastLength(LLValue* len, LLType* elemty, LLType* newelemty)
LLConstantInt::get(DtoSize_t(), nsz, false)
};
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_array_cast_len");
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_array_cast_len");
return gIR->CreateCallOrInvoke(fn, args, "tmp").getInstruction();
}
@ -1057,13 +1057,13 @@ DValue* DtoCastArray(Loc& loc, DValue* u, Type* to)
uinteger_t len = static_cast<TypeSArray*>(fromtype)->dim->toUInteger();
rval2 = LLConstantInt::get(DtoSize_t(), len, false);
if (fromtype->nextOf()->size() != totype->nextOf()->size())
rval2 = DtoArrayCastLength(rval2, ety, ptrty->getContainedType(0));
rval2 = DtoArrayCastLength(loc, rval2, ety, ptrty->getContainedType(0));
rval = DtoBitCast(uval, ptrty);
}
else {
rval2 = DtoArrayLen(u);
if (fromtype->nextOf()->size() != totype->nextOf()->size())
rval2 = DtoArrayCastLength(rval2, ety, ptrty->getContainedType(0));
rval2 = DtoArrayCastLength(loc, rval2, ety, ptrty->getContainedType(0));
rval = DtoArrayPtr(u);
rval = DtoBitCast(rval, ptrty);
@ -1178,7 +1178,7 @@ void DtoArrayBoundsCheck(Loc& loc, DValue* arr, DValue* index, DValue* lowerBoun
args.push_back(c);
// call
llvm::Function* errorfn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_array_bounds");
llvm::Function* errorfn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_array_bounds");
gIR->CreateCallOrInvoke(errorfn, args);
// the function does not return

20
gen/arrays.h
View file

@ -45,26 +45,26 @@ llvm::Constant* arrayLiteralToConst(IRState* p, ArrayLiteralExp* ale);
/// dstMem is expected to be a pointer to the array allocation.
void initializeArrayLiteral(IRState* p, ArrayLiteralExp* ale, LLValue* dstMem);
void DtoArrayCopySlices(DSliceValue* dst, DSliceValue* src);
void DtoArrayCopyToSlice(DSliceValue* dst, DValue* src);
void DtoArrayCopySlices(Loc& loc, DSliceValue* dst, DSliceValue* src);
void DtoArrayCopyToSlice(Loc& loc, DSliceValue* dst, DValue* src);
void DtoArrayInit(Loc& loc, DValue* array, DValue* value, int op);
Type *DtoArrayElementType(Type *arrayType);
bool arrayNeedsPostblit(Type *t);
void DtoArrayAssign(DValue *from, DValue *to, int op);
void DtoArraySetAssign(Loc &loc, DValue *array, DValue *value, int op);
void DtoArrayAssign(Loc& loc, DValue *from, DValue *to, int op);
void DtoArraySetAssign(Loc& loc, DValue *array, DValue *value, int op);
void DtoSetArray(DValue* array, LLValue* dim, LLValue* ptr);
void DtoSetArrayToNull(LLValue* v);
DSliceValue* DtoNewDynArray(Loc& loc, Type* arrayType, DValue* dim, bool defaultInit=true);
DSliceValue* DtoNewMulDimDynArray(Loc& loc, Type* arrayType, DValue** dims, size_t ndims, bool defaultInit=true);
DSliceValue* DtoResizeDynArray(Type* arrayType, DValue* array, llvm::Value* newdim);
DSliceValue* DtoResizeDynArray(Loc& loc, Type* arrayType, DValue* array, llvm::Value* newdim);
void DtoCatAssignElement(Loc& loc, Type* type, DValue* arr, Expression* exp);
DSliceValue* DtoCatAssignArray(DValue* arr, Expression* exp);
DSliceValue* DtoCatArrays(Type* type, Expression* e1, Expression* e2);
DSliceValue* DtoAppendDCharToString(DValue* arr, Expression* exp);
DSliceValue* DtoAppendDCharToUnicodeString(DValue* arr, Expression* exp);
DSliceValue* DtoCatAssignArray(Loc& loc, DValue* arr, Expression* exp);
DSliceValue* DtoCatArrays(Loc& loc, Type* type, Expression* e1, Expression* e2);
DSliceValue* DtoAppendDCharToString(Loc& loc, DValue* arr, Expression* exp);
DSliceValue* DtoAppendDCharToUnicodeString(Loc& loc, DValue* arr, Expression* exp);
void DtoStaticArrayCopy(LLValue* dst, LLValue* src);
@ -73,7 +73,7 @@ LLValue* DtoArrayCompare(Loc& loc, TOK op, DValue* l, DValue* r);
LLValue* DtoDynArrayIs(TOK op, DValue* l, DValue* r);
LLValue* DtoArrayCastLength(LLValue* len, LLType* elemty, LLType* newelemty);
LLValue* DtoArrayCastLength(Loc& loc, LLValue* len, LLType* elemty, LLType* newelemty);
LLValue* DtoArrayLen(DValue* v);
LLValue* DtoArrayPtr(DValue* v);

4
gen/binops.cpp
View file

@ -108,7 +108,7 @@ DValue* DtoBinRem(Type* targettype, DValue* lhs, DValue* rhs)
//////////////////////////////////////////////////////////////////////////////
LLValue* DtoBinNumericEquals(Loc loc, DValue* lhs, DValue* rhs, TOK op)
LLValue* DtoBinNumericEquals(Loc& loc, DValue* lhs, DValue* rhs, TOK op)
{
assert(op == TOKequal || op == TOKnotequal ||
op == TOKidentity || op == TOKnotidentity);
@ -134,7 +134,7 @@ LLValue* DtoBinNumericEquals(Loc loc, DValue* lhs, DValue* rhs, TOK op)
//////////////////////////////////////////////////////////////////////////////
LLValue* DtoBinFloatsEquals(Loc loc, DValue* lhs, DValue* rhs, TOK op)
LLValue* DtoBinFloatsEquals(Loc& loc, DValue* lhs, DValue* rhs, TOK op)
{
LLValue* res = 0;
if (op == TOKequal) {

31
gen/classes.cpp
View file

@ -82,7 +82,7 @@ void DtoResolveClass(ClassDeclaration* cd)
//////////////////////////////////////////////////////////////////////////////////////////
DValue* DtoNewClass(Loc loc, TypeClass* tc, NewExp* newexp)
DValue* DtoNewClass(Loc& loc, TypeClass* tc, NewExp* newexp)
{
// resolve type
DtoResolveClass(tc->sym);
@ -105,7 +105,7 @@ DValue* DtoNewClass(Loc loc, TypeClass* tc, NewExp* newexp)
// default allocator
else
{
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_newclass");
llvm::Function* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_newclass");
LLConstant* ci = DtoBitCast(tc->sym->ir.irAggr->getClassInfoSymbol(), DtoType(Type::typeinfoclass->type));
mem = gIR->CreateCallOrInvoke(fn, ci, ".newclass_gc_alloc").getInstruction();
mem = DtoBitCast(mem, DtoType(tc), ".newclass_gc");
@ -185,10 +185,10 @@ void DtoInitClass(TypeClass* tc, LLValue* dst)
//////////////////////////////////////////////////////////////////////////////////////////
void DtoFinalizeClass(LLValue* inst)
void DtoFinalizeClass(Loc& loc, LLValue* inst)
{
// get runtime function
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_callfinalizer");
llvm::Function* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_callfinalizer");
// build args
LLValue* arg[] = {
DtoBitCast(inst, fn->getFunctionType()->getParamType(0), ".tmp")
@ -199,7 +199,7 @@ void DtoFinalizeClass(LLValue* inst)
//////////////////////////////////////////////////////////////////////////////////////////
DValue* DtoCastClass(DValue* val, Type* _to)
DValue* DtoCastClass(Loc& loc, DValue* val, Type* _to)
{
IF_LOG Logger::println("DtoCastClass(%s, %s)", val->getType()->toChars(), _to->toChars());
LOG_SCOPE;
@ -230,7 +230,6 @@ DValue* DtoCastClass(DValue* val, Type* _to)
v = gIR->ir->CreatePtrToInt(v, DtoSize_t(), "");
// cast to the final int type
DImValue im(Type::tsize_t, v);
Loc loc;
return DtoCastInt(loc, &im, _to);
}
@ -248,7 +247,7 @@ DValue* DtoCastClass(DValue* val, Type* _to)
// interface -> interface
if (fc->sym->isInterfaceDeclaration()) {
Logger::println("from interface");
return DtoDynamicCastInterface(val, _to);
return DtoDynamicCastInterface(loc, val, _to);
}
// class -> interface - static cast
else if (it->isBaseOf(fc->sym,NULL)) {
@ -288,7 +287,7 @@ DValue* DtoCastClass(DValue* val, Type* _to)
// class -> interface
else {
Logger::println("from object");
return DtoDynamicCastObject(val, _to);
return DtoDynamicCastObject(loc, val, _to);
}
}
// x -> class
@ -297,7 +296,7 @@ DValue* DtoCastClass(DValue* val, Type* _to)
// interface -> class
if (fc->sym->isInterfaceDeclaration()) {
Logger::println("interface cast");
return DtoDynamicCastInterface(val, _to);
return DtoDynamicCastInterface(loc, val, _to);
}
// class -> class - static down cast
else if (tc->sym->isBaseOf(fc->sym,NULL)) {
@ -309,14 +308,14 @@ DValue* DtoCastClass(DValue* val, Type* _to)
// class -> class - dynamic up cast
else {
Logger::println("dynamic up cast");
return DtoDynamicCastObject(val, _to);
return DtoDynamicCastObject(loc, val, _to);
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////
DValue* DtoDynamicCastObject(DValue* val, Type* _to)
DValue* DtoDynamicCastObject(Loc& loc, DValue* val, Type* _to)
{
// call:
// Object _d_dynamic_cast(Object o, ClassInfo c)
@ -324,7 +323,7 @@ DValue* DtoDynamicCastObject(DValue* val, Type* _to)
DtoResolveClass(ClassDeclaration::object);
DtoResolveClass(Type::typeinfoclass);
llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, "_d_dynamic_cast");
llvm::Function* func = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_dynamic_cast");
LLFunctionType* funcTy = func->getFunctionType();
// Object o
@ -353,12 +352,12 @@ DValue* DtoDynamicCastObject(DValue* val, Type* _to)
//////////////////////////////////////////////////////////////////////////////////////////
DValue* DtoCastInterfaceToObject(DValue* val, Type* to)
DValue* DtoCastInterfaceToObject(Loc& loc, DValue* val, Type* to)
{
// call:
// Object _d_toObject(void* p)
llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, "_d_toObject");
llvm::Function* func = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_toObject");
LLFunctionType* funcTy = func->getFunctionType();
// void* p
@ -379,7 +378,7 @@ DValue* DtoCastInterfaceToObject(DValue* val, Type* to)
//////////////////////////////////////////////////////////////////////////////////////////
DValue* DtoDynamicCastInterface(DValue* val, Type* _to)
DValue* DtoDynamicCastInterface(Loc& loc, DValue* val, Type* _to)
{
// call:
// Object _d_interface_cast(void* p, ClassInfo c)
@ -387,7 +386,7 @@ DValue* DtoDynamicCastInterface(DValue* val, Type* _to)
DtoResolveClass(ClassDeclaration::object);
DtoResolveClass(Type::typeinfoclass);
llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, "_d_interface_cast");
llvm::Function* func = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_interface_cast");
LLFunctionType* funcTy = func->getFunctionType();
// void* p

12
gen/classes.h
View file

@ -39,15 +39,15 @@ void DtoDefineClass(ClassDeclaration* cd);
/// FIXME: this should be put into IrStruct and eventually IrClass.
llvm::Constant* DtoDefineClassInfo(ClassDeclaration* cd);
DValue* DtoNewClass(Loc loc, TypeClass* type, NewExp* newexp);
DValue* DtoNewClass(Loc& loc, TypeClass* type, NewExp* newexp);
void DtoInitClass(TypeClass* tc, llvm::Value* dst);
void DtoFinalizeClass(llvm::Value* inst);
void DtoFinalizeClass(Loc& loc, llvm::Value* inst);
DValue* DtoCastClass(DValue* val, Type* to);
DValue* DtoDynamicCastObject(DValue* val, Type* to);
DValue* DtoCastClass(Loc& loc, DValue* val, Type* to);
DValue* DtoDynamicCastObject(Loc& loc, DValue* val, Type* to);
DValue* DtoCastInterfaceToObject(DValue* val, Type* to);
DValue* DtoDynamicCastInterface(DValue* val, Type* to);
DValue* DtoCastInterfaceToObject(Loc& loc, DValue* val, Type* to);
DValue* DtoDynamicCastInterface(Loc& loc, DValue* val, Type* to);
llvm::Value* DtoIndexClass(llvm::Value* src, ClassDeclaration* sd, VarDeclaration* vd);

16
gen/dibuilder.cpp
View file

@ -69,7 +69,7 @@ void ldc::DIBuilder::Declare(llvm::Value *var, llvm::DIVariable divar)
instr->setDebugLoc(IR->ir->getCurrentDebugLocation());
}
llvm::DIFile ldc::DIBuilder::CreateFile(Loc loc)
llvm::DIFile ldc::DIBuilder::CreateFile(Loc& loc)
{
llvm::SmallString<128> path(loc.filename ? loc.filename : "");
llvm::sys::fs::make_absolute(path);
@ -392,7 +392,8 @@ llvm::DIType ldc::DIBuilder::CreateArrayType(Type *type)
assert(t->ty == Tarray && "Only arrays allowed for debug info in DIBuilder::CreateArrayType");
llvm::DIFile file = CreateFile(Loc(IR->dmodule, 0));
Loc loc(IR->dmodule, 0);
llvm::DIFile file = CreateFile(loc);
llvm::Value *elems[] = {
CreateMemberType(0, Type::tsize_t, file, "length", 0),
@ -458,7 +459,8 @@ ldc::DIFunctionType ldc::DIBuilder::CreateFunctionType(Type *type)
TypeFunction *t = static_cast<TypeFunction*>(type);
Type *retType = t->next;
llvm::DIFile file = CreateFile(Loc(IR->dmodule, 0));
Loc loc(IR->dmodule, 0);
llvm::DIFile file = CreateFile(loc);
// Create "dummy" subroutine type for the return type
llvm::SmallVector<llvm::Value*, 16> Elts;
@ -472,7 +474,8 @@ ldc::DIFunctionType ldc::DIBuilder::CreateDelegateType(Type *type)
// FIXME: Implement
TypeDelegate *t = static_cast<TypeDelegate*>(type);
llvm::DIFile file = CreateFile(Loc(IR->dmodule, 0));
Loc loc(IR->dmodule, 0);
llvm::DIFile file = CreateFile(loc);
// Create "dummy" subroutine type for the return type
llvm::SmallVector<llvm::Value*, 16> Elts;
@ -607,7 +610,8 @@ llvm::DISubprogram ldc::DIBuilder::EmitSubProgramInternal(llvm::StringRef pretty
Logger::println("D to dwarf subprogram");
LOG_SCOPE;
llvm::DIFile file(CreateFile(Loc(IR->dmodule, 0)));
Loc loc(IR->dmodule, 0);
llvm::DIFile file(CreateFile(loc));
// Create "dummy" subroutine type for the return type
llvm::SmallVector<llvm::Value *, 1> Elts;
@ -656,7 +660,7 @@ void ldc::DIBuilder::EmitFuncEnd(FuncDeclaration *fd)
assert(static_cast<llvm::MDNode *>(fd->ir.irFunc->diSubprogram) != 0);
}
void ldc::DIBuilder::EmitBlockStart(Loc loc)
void ldc::DIBuilder::EmitBlockStart(Loc& loc)
{
if (!global.params.symdebug)
return;

4
gen/dibuilder.h
View file

@ -113,7 +113,7 @@ public:
void EmitFuncEnd(FuncDeclaration *fd);
/// \brief Emits debug info for block start
void EmitBlockStart(Loc loc);
void EmitBlockStart(Loc& loc);
/// \brief Emits debug info for block end
void EmitBlockEnd();
@ -143,7 +143,7 @@ private:
void Declare(llvm::Value *var, llvm::DIVariable divar);
void AddBaseFields(ClassDeclaration *sd, llvm::DIFile file,
std::vector<llvm::Value*> &elems);
llvm::DIFile CreateFile(Loc loc);
llvm::DIFile CreateFile(Loc& loc);
llvm::DIType CreateBasicType(Type *type);
llvm::DIType CreateEnumType(Type *type);
llvm::DIType CreatePointerType(Type *type);

2
gen/functions.h
View file

@ -39,7 +39,7 @@ void DtoDeclareFunction(FuncDeclaration* fdecl);
void DtoDefineFunction(FuncDeclaration* fd);
void DtoDefineNakedFunction(FuncDeclaration* fd);
void emitABIReturnAsmStmt(IRAsmBlock* asmblock, Loc loc, FuncDeclaration* fdecl);
void emitABIReturnAsmStmt(IRAsmBlock* asmblock, Loc& loc, FuncDeclaration* fdecl);
DValue* DtoArgument(Parameter* fnarg, Expression* argexp);
void DtoVariadicArgument(Expression* argexp, llvm::Value* dst);

74
gen/llvmhelpers.cpp
View file

@ -58,10 +58,10 @@ llvm::cl::opt<llvm::GlobalVariable::ThreadLocalMode> clThreadModel("fthread-mode
// DYNAMIC MEMORY HELPERS
////////////////////////////////////////////////////////////////////////////////////////*/
LLValue* DtoNew(Type* newtype)
LLValue* DtoNew(Loc& loc, Type* newtype)
{
// get runtime function
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_allocmemoryT");
llvm::Function* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_allocmemoryT");
// get type info
LLConstant* ti = DtoTypeInfoOf(newtype);
assert(isaPointer(ti));
@ -71,20 +71,20 @@ LLValue* DtoNew(Type* newtype)
return DtoBitCast(mem, getPtrToType(i1ToI8(DtoType(newtype))), ".gc_mem");
}
void DtoDeleteMemory(LLValue* ptr)
void DtoDeleteMemory(Loc& loc, LLValue* ptr)
{
// get runtime function
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_delmemory");
llvm::Function* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_delmemory");
// build args
LLValue* arg[] = { DtoBitCast(ptr, getVoidPtrType(), ".tmp") };
// call
gIR->CreateCallOrInvoke(fn, arg);
}
void DtoDeleteClass(LLValue* inst)
void DtoDeleteClass(Loc& loc, LLValue* inst)
{
// get runtime function
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_delclass");
llvm::Function* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_delclass");
// druntime wants a pointer to object
LLValue *ptr = DtoRawAlloca(inst->getType(), 0, "objectPtr");
DtoStore(inst, ptr);
@ -97,10 +97,10 @@ void DtoDeleteClass(LLValue* inst)
gIR->CreateCallOrInvoke(fn, arg);
}
void DtoDeleteInterface(LLValue* inst)
void DtoDeleteInterface(Loc& loc, LLValue* inst)
{
// get runtime function
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_delinterface");
llvm::Function* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_delinterface");
// build args
LLValue* arg[] = {
DtoBitCast(inst, fn->getFunctionType()->getParamType(0), ".tmp")
@ -109,10 +109,10 @@ void DtoDeleteInterface(LLValue* inst)
gIR->CreateCallOrInvoke(fn, arg);
}
void DtoDeleteArray(DValue* arr)
void DtoDeleteArray(Loc& loc, DValue* arr)
{
// get runtime function
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_delarray_t");
llvm::Function* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_delarray_t");
// build args
LLValue* arg[] = {
@ -155,10 +155,10 @@ llvm::AllocaInst* DtoRawAlloca(LLType* lltype, size_t alignment, const char* nam
return ai;
}
LLValue* DtoGcMalloc(LLType* lltype, const char* name)
LLValue* DtoGcMalloc(Loc& loc, LLType* lltype, const char* name)
{
// get runtime function
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_allocmemory");
llvm::Function* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_allocmemory");
// parameters
LLValue *size = DtoConstSize_t(getTypeAllocSize(lltype));
// call runtime allocator
@ -172,11 +172,11 @@ LLValue* DtoGcMalloc(LLType* lltype, const char* name)
// ASSERT HELPER
////////////////////////////////////////////////////////////////////////////////////////*/
void DtoAssert(Module* M, Loc loc, DValue* msg)
void DtoAssert(Module* M, Loc& loc, DValue* msg)
{
// func
const char* fname = msg ? "_d_assert_msg" : "_d_assert";
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, fname);
llvm::Function* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, fname);
// Arguments
llvm::SmallVector<LLValue*, 3> args;
@ -239,7 +239,7 @@ LabelStatement* DtoLabelStatement(Identifier* ident)
/*////////////////////////////////////////////////////////////////////////////////////////
// GOTO HELPER
////////////////////////////////////////////////////////////////////////////////////////*/
void DtoGoto(Loc loc, Identifier* target, TryFinallyStatement* sourceFinally)
void DtoGoto(Loc& loc, Identifier* target, TryFinallyStatement* sourceFinally)
{
assert(!gIR->scopereturned());
@ -276,9 +276,9 @@ void DtoGoto(Loc loc, Identifier* target, TryFinallyStatement* sourceFinally)
void EnclosingSynchro::emitCode(IRState * p)
{
if (s->exp)
DtoLeaveMonitor(s->exp->toElem(p)->getRVal());
DtoLeaveMonitor(s->exp->loc, s->exp->toElem(p)->getRVal());
else
DtoLeaveCritical(s->llsync);
DtoLeaveCritical(s->loc, s->llsync);
}
////////////////////////////////////////////////////////////////////////////////////////
@ -296,7 +296,7 @@ void EnclosingTryFinally::emitCode(IRState * p)
////////////////////////////////////////////////////////////////////////////////////////
void DtoEnclosingHandlers(Loc loc, Statement* target)
void DtoEnclosingHandlers(Loc& loc, Statement* target)
{
// labels are a special case: they are not required to enclose the current scope
// for them we use the enclosing scope handler as a reference point
@ -343,28 +343,28 @@ void DtoEnclosingHandlers(Loc loc, Statement* target)
// SYNCHRONIZED SECTION HELPERS
////////////////////////////////////////////////////////////////////////////////////////*/
void DtoEnterCritical(LLValue* g)
void DtoEnterCritical(Loc& loc, LLValue* g)
{
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_criticalenter");
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_criticalenter");
gIR->CreateCallOrInvoke(fn, g);
}
void DtoLeaveCritical(LLValue* g)
void DtoLeaveCritical(Loc& loc, LLValue* g)
{
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_criticalexit");
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_criticalexit");
gIR->CreateCallOrInvoke(fn, g);
}
void DtoEnterMonitor(LLValue* v)
void DtoEnterMonitor(Loc& loc, LLValue* v)
{
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_monitorenter");
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_monitorenter");
v = DtoBitCast(v, fn->getFunctionType()->getParamType(0));
gIR->CreateCallOrInvoke(fn, v);
}
void DtoLeaveMonitor(LLValue* v)
void DtoLeaveMonitor(Loc& loc, LLValue* v)
{
LLFunction* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_monitorexit");
LLFunction* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_monitorexit");
v = DtoBitCast(v, fn->getFunctionType()->getParamType(0));
gIR->CreateCallOrInvoke(fn, v);
}
@ -411,13 +411,13 @@ void DtoAssign(Loc& loc, DValue* lhs, DValue* rhs, int op, bool canSkipPostblit)
else if (op != -1 && op != TOKblit && !canSkipPostblit &&
arrayNeedsPostblit(t)
) {
DtoArrayAssign(s, rhs, op);
DtoArrayAssign(loc, s, rhs, op);
}
else if (DSliceValue *s2 = rhs->isSlice()) {
DtoArrayCopySlices(s, s2);
DtoArrayCopySlices(loc, s, s2);
}
else {
DtoArrayCopyToSlice(s, rhs);
DtoArrayCopyToSlice(loc, s, rhs);
}
}
// rhs is slice
@ -449,7 +449,7 @@ void DtoAssign(Loc& loc, DValue* lhs, DValue* rhs, int op, bool canSkipPostblit)
else if (op != -1 && op != TOKblit && !canSkipPostblit &&
arrayNeedsPostblit(t)
) {
DtoArrayAssign(lhs, rhs, op);
DtoArrayAssign(loc, lhs, rhs, op);
}
// T[n] = T[n]
else if (DtoType(lhs->getType()) == DtoType(rhs->getType())) {
@ -861,7 +861,7 @@ DValue* DtoCast(Loc& loc, DValue* val, Type* to)
return DtoCastFloat(loc, val, to);
}
else if (fromtype->ty == Tclass) {
return DtoCastClass(val, to);
return DtoCastClass(loc, val, to);
}
else if (fromtype->ty == Tarray || fromtype->ty == Tsarray) {
return DtoCastArray(loc, val, to);
@ -1340,7 +1340,7 @@ LLValue* DtoRawVarDeclaration(VarDeclaration* var, LLValue* addr)
// INITIALIZER HELPERS
////////////////////////////////////////////////////////////////////////////////////////*/
LLConstant* DtoConstInitializer(Loc loc, Type* type, Initializer* init)
LLConstant* DtoConstInitializer(Loc& loc, Type* type, Initializer* init)
{
LLConstant* _init = 0; // may return zero
if (!init)
@ -1378,7 +1378,7 @@ LLConstant* DtoConstInitializer(Loc loc, Type* type, Initializer* init)
//////////////////////////////////////////////////////////////////////////////////////////
LLConstant* DtoConstExpInit(Loc loc, Type* targetType, Expression* exp)
LLConstant* DtoConstExpInit(Loc& loc, Type* targetType, Expression* exp)
{
IF_LOG Logger::println("DtoConstExpInit(targetType = %s, exp = %s)",
targetType->toChars(), exp->toChars());
@ -1665,7 +1665,7 @@ LLValue* makeLValue(Loc& loc, DValue* value)
//////////////////////////////////////////////////////////////////////////////////////////
void callPostblit(Loc &loc, Expression *exp, LLValue *val)
void callPostblit(Loc& loc, Expression *exp, LLValue *val)
{
Type *tb = exp->type->toBasetype();
@ -1757,7 +1757,7 @@ void tokToIcmpPred(TOK op, bool isUnsigned, llvm::ICmpInst::Predicate* outPred,
}
///////////////////////////////////////////////////////////////////////////////
DValue* DtoSymbolAddress(const Loc& loc, Type* type, Declaration* decl)
DValue* DtoSymbolAddress(Loc& loc, Type* type, Declaration* decl)
{
IF_LOG Logger::println("DtoSymbolAddress ('%s' of type '%s')",
decl->toChars(), decl->type->toChars());
@ -1927,7 +1927,7 @@ DValue* DtoSymbolAddress(const Loc& loc, Type* type, Declaration* decl)
llvm_unreachable("Unimplemented VarExp type");
}
llvm::Constant* DtoConstSymbolAddress(const Loc& loc, Declaration* decl)
llvm::Constant* DtoConstSymbolAddress(Loc& loc, Declaration* decl)
{
// Make sure 'this' isn't needed.
// TODO: This check really does not belong here, should be moved to
@ -1969,7 +1969,7 @@ llvm::Constant* DtoConstSymbolAddress(const Loc& loc, Declaration* decl)
llvm_unreachable("Taking constant address not implemented.");
}
llvm::GlobalVariable* getOrCreateGlobal(Loc loc, llvm::Module& module,
llvm::GlobalVariable* getOrCreateGlobal(Loc& loc, llvm::Module& module,
llvm::Type* type, bool isConstant, llvm::GlobalValue::LinkageTypes linkage,
llvm::Constant* init, llvm::StringRef name, bool isThreadLocal)
{

44
gen/llvmhelpers.h
View file

@ -44,47 +44,47 @@ struct EnclosingSynchro : EnclosingHandler
// dynamic memory helpers
LLValue* DtoNew(Type* newtype);
void DtoDeleteMemory(LLValue* ptr);
void DtoDeleteClass(LLValue* inst);
void DtoDeleteInterface(LLValue* inst);
void DtoDeleteArray(DValue* arr);
LLValue* DtoNew(Loc& loc, Type* newtype);
void DtoDeleteMemory(Loc& loc, LLValue* ptr);
void DtoDeleteClass(Loc& loc, LLValue* inst);
void DtoDeleteInterface(Loc& loc, LLValue* inst);
void DtoDeleteArray(Loc& loc, DValue* arr);
// emit an alloca
llvm::AllocaInst* DtoAlloca(Type* type, const char* name = "");
llvm::AllocaInst* DtoArrayAlloca(Type* type, unsigned arraysize, const char* name = "");
llvm::AllocaInst* DtoRawAlloca(LLType* lltype, size_t alignment, const char* name = "");
LLValue* DtoGcMalloc(LLType* lltype, const char* name = "");
LLValue* DtoGcMalloc(Loc& loc, LLType* lltype, const char* name = "");
// assertion generator
void DtoAssert(Module* M, Loc loc, DValue* msg);
void DtoAssert(Module* M, Loc& loc, DValue* msg);
// return the LabelStatement from the current function with the given identifier or NULL if not found
LabelStatement* DtoLabelStatement(Identifier* ident);
/// emits goto to LabelStatement with the target identifier
/// the sourceFinally is only used for error checking
void DtoGoto(Loc loc, Identifier* target, TryFinallyStatement* sourceFinally);
void DtoGoto(Loc& loc, Identifier* target, TryFinallyStatement* sourceFinally);
// Generates IR for enclosing handlers between the current state and
// the scope created by the 'target' statement.
void DtoEnclosingHandlers(Loc loc, Statement* target);
void DtoEnclosingHandlers(Loc& loc, Statement* target);
/// Enters a critical section.
void DtoEnterCritical(LLValue* g);
void DtoEnterCritical(Loc& loc, LLValue* g);
/// leaves a critical section.
void DtoLeaveCritical(LLValue* g);
void DtoLeaveCritical(Loc& loc, LLValue* g);
/// Enters a monitor lock.
void DtoEnterMonitor(LLValue* v);
void DtoEnterMonitor(Loc& loc, LLValue* v);
/// Leaves a monitor lock.
void DtoLeaveMonitor(LLValue* v);
void DtoLeaveMonitor(Loc& loc, LLValue* v);
// basic operations
void DtoAssign(Loc& loc, DValue* lhs, DValue* rhs, int op = -1, bool canSkipPostblit = false);
DValue* DtoSymbolAddress(const Loc& loc, Type* type, Declaration* decl);
llvm::Constant* DtoConstSymbolAddress(const Loc& loc,Declaration* decl);
DValue* DtoSymbolAddress(Loc& loc, Type* type, Declaration* decl);
llvm::Constant* DtoConstSymbolAddress(Loc& loc,Declaration* decl);
/// Create a null DValue.
DValue* DtoNullValue(Type* t);
@ -118,8 +118,8 @@ DValue* DtoDeclarationExp(Dsymbol* declaration);
LLValue* DtoRawVarDeclaration(VarDeclaration* var, LLValue* addr = 0);
// initializer helpers
LLConstant* DtoConstInitializer(Loc loc, Type* type, Initializer* init);
LLConstant* DtoConstExpInit(Loc loc, Type* targetType, Expression* exp);
LLConstant* DtoConstInitializer(Loc& loc, Type* type, Initializer* init);
LLConstant* DtoConstExpInit(Loc& loc, Type* targetType, Expression* exp);
// getting typeinfo of type, base=true casts to object.TypeInfo
LLConstant* DtoTypeInfoOf(Type* ty, bool base=true);
@ -132,8 +132,8 @@ DValue* DtoBinSub(DValue* lhs, DValue* rhs);
DValue* DtoBinMul(Type* resulttype, DValue* lhs, DValue* rhs);
DValue* DtoBinDiv(Type* resulttype, DValue* lhs, DValue* rhs);
DValue* DtoBinRem(Type* resulttype, DValue* lhs, DValue* rhs);
LLValue* DtoBinNumericEquals(Loc loc, DValue* lhs, DValue* rhs, TOK op);
LLValue* DtoBinFloatsEquals(Loc loc, DValue* lhs, DValue* rhs, TOK op);
LLValue* DtoBinNumericEquals(Loc& loc, DValue* lhs, DValue* rhs, TOK op);
LLValue* DtoBinFloatsEquals(Loc& loc, DValue* lhs, DValue* rhs, TOK op);
// target stuff
void findDefaultTarget();
@ -145,7 +145,7 @@ void DtoOverloadedIntrinsicName(TemplateInstance* ti, TemplateDeclaration* td, s
bool hasUnalignedFields(Type* t);
///
DValue* DtoInlineAsmExpr(Loc loc, FuncDeclaration* fd, Expressions* arguments);
DValue* DtoInlineAsmExpr(Loc& loc, FuncDeclaration* fd, Expressions* arguments);
/// Create the IrModule if necessary and returns it.
IrModule* getIrModule(Module* M);
@ -159,7 +159,7 @@ size_t realignOffset(size_t offset, Type* type);
/// functions without problems.
LLValue* makeLValue(Loc& loc, DValue* value);
void callPostblit(Loc &loc, Expression *exp, LLValue *val);
void callPostblit(Loc& loc, Expression *exp, LLValue *val);
/// Returns whether the given variable is a DMD-internal "ref variable".
///
@ -235,7 +235,7 @@ LLConstant* toConstantArray(LLType* ct, LLArrayType* at, T* str, size_t len, boo
///
/// Necessary to support multiple declarations with the same mangled name, as
/// can be the case due to pragma(mangle).
llvm::GlobalVariable* getOrCreateGlobal(Loc loc, llvm::Module& module,
llvm::GlobalVariable* getOrCreateGlobal(Loc& loc, llvm::Module& module,
llvm::Type* type, bool isConstant, llvm::GlobalValue::LinkageTypes linkage,
llvm::Constant* init, llvm::StringRef name, bool isThreadLocal = false);

2
gen/logger.cpp
View file

@ -128,7 +128,7 @@ namespace Logger
va_end(va);
}
}
void attention(Loc loc, const char* fmt,...)
void attention(Loc& loc, const char* fmt,...)
{
va_list va;
va_start(va,fmt);

5
gen/module.cpp
View file

@ -302,7 +302,8 @@ static LLFunction* build_module_reference_and_ctor(LLConstant* moduleinfo)
std::string thismrefname = "_D";
thismrefname += gIR->dmodule->mangle();
thismrefname += "11__moduleRefZ";
LLGlobalVariable* thismref = getOrCreateGlobal(Loc(), *gIR->module,
Loc loc;
LLGlobalVariable* thismref = getOrCreateGlobal(loc, *gIR->module,
modulerefTy, false, LLGlobalValue::InternalLinkage, thismrefinit,
thismrefname);
// make sure _Dmodule_ref is declared
@ -352,7 +353,7 @@ static void build_dso_ctor_dtor_body(
llvm::Value* minfoUsedPointer,
bool executeWhenInitialized
) {
llvm::Function* const dsoRegistry = LLVM_D_GetRuntimeFunction(
llvm::Function* const dsoRegistry = LLVM_D_GetRuntimeFunction(Loc(),
gIR->module, "_d_dso_registry");
llvm::Type* const recordPtrTy = dsoRegistry->getFunctionType()->getContainedType(1);

4
gen/naked.cpp
View file

@ -257,7 +257,7 @@ void DtoDefineNakedFunction(FuncDeclaration* fd)
//////////////////////////////////////////////////////////////////////////////////////////
void emitABIReturnAsmStmt(IRAsmBlock* asmblock, Loc loc, FuncDeclaration* fdecl)
void emitABIReturnAsmStmt(IRAsmBlock* asmblock, Loc& loc, FuncDeclaration* fdecl)
{
IF_LOG Logger::println("emitABIReturnAsmStmt(%s)", fdecl->mangleExact());
LOG_SCOPE;
@ -414,7 +414,7 @@ void emitABIReturnAsmStmt(IRAsmBlock* asmblock, Loc loc, FuncDeclaration* fdecl)
// sort of kinda related to naked ...
DValue * DtoInlineAsmExpr(Loc loc, FuncDeclaration * fd, Expressions * arguments)
DValue * DtoInlineAsmExpr(Loc& loc, FuncDeclaration * fd, Expressions * arguments)
{
IF_LOG Logger::println("DtoInlineAsmExpr @ %s", loc.toChars());
LOG_SCOPE;

10
gen/nested.cpp
View file

@ -32,7 +32,7 @@ static void storeVariable(VarDeclaration *vd, LLValue *dst)
assert(fd && "No parent function for nested variable?");
if (fd->needsClosure() && !vd->isRef() && (ty == Tstruct || ty == Tsarray) && isaPointer(value->getType())) {
// Copy structs and static arrays
LLValue *mem = DtoGcMalloc(DtoType(vd->type), ".gc_mem");
LLValue *mem = DtoGcMalloc(vd->loc, DtoType(vd->type), ".gc_mem");
DtoAggrCopy(mem, value);
DtoAlignedStore(mem, dst);
} else
@ -42,7 +42,7 @@ static void storeVariable(VarDeclaration *vd, LLValue *dst)
static void DtoCreateNestedContextType(FuncDeclaration* fd);
DValue* DtoNestedVariable(Loc loc, Type* astype, VarDeclaration* vd, bool byref)
DValue* DtoNestedVariable(Loc& loc, Type* astype, VarDeclaration* vd, bool byref)
{
IF_LOG Logger::println("DtoNestedVariable for %s @ %s", vd->toChars(), loc.toChars());
LOG_SCOPE;
@ -165,7 +165,7 @@ DValue* DtoNestedVariable(Loc loc, Type* astype, VarDeclaration* vd, bool byref)
return new DVarValue(astype, vd, val);
}
void DtoResolveNestedContext(Loc loc, AggregateDeclaration *decl, LLValue *value)
void DtoResolveNestedContext(Loc& loc, AggregateDeclaration *decl, LLValue *value)
{
IF_LOG Logger::println("Resolving nested context");
LOG_SCOPE;
@ -189,7 +189,7 @@ void DtoResolveNestedContext(Loc loc, AggregateDeclaration *decl, LLValue *value
}
}
LLValue* DtoNestedContext(Loc loc, Dsymbol* sym)
LLValue* DtoNestedContext(Loc& loc, Dsymbol* sym)
{
IF_LOG Logger::println("DtoNestedContext for %s", sym->toPrettyChars());
LOG_SCOPE;
@ -416,7 +416,7 @@ void DtoCreateNestedContext(FuncDeclaration* fd) {
LLValue* frame = 0;
bool needsClosure = fd->needsClosure();
if (needsClosure)
frame = DtoGcMalloc(frameType, ".frame");
frame = DtoGcMalloc(fd->loc, frameType, ".frame");
else
frame = DtoRawAlloca(frameType, 0, ".frame");

6
gen/nested.h
View file

@ -28,13 +28,13 @@
void DtoCreateNestedContext(FuncDeclaration* fd);
/// Resolves the nested context for classes and structs with arbitrary nesting.
void DtoResolveNestedContext(Loc loc, AggregateDeclaration *decl, LLValue *value);
void DtoResolveNestedContext(Loc& loc, AggregateDeclaration *decl, LLValue *value);
/// Gets the context value for a call to a nested function or creating a nested
/// class or struct with arbitrary nesting.
llvm::Value* DtoNestedContext(Loc loc, Dsymbol* sym);
llvm::Value* DtoNestedContext(Loc& loc, Dsymbol* sym);
/// Gets the DValue of a nested variable with arbitrary nesting.
DValue* DtoNestedVariable(Loc loc, Type* astype, VarDeclaration* vd, bool byref = false);
DValue* DtoNestedVariable(Loc& loc, Type* astype, VarDeclaration* vd, bool byref = false);
#endif

12
gen/runtime.cpp
View file

@ -126,9 +126,9 @@ void LLVM_D_FreeRuntime()
//////////////////////////////////////////////////////////////////////////////////////////////////
llvm::Function* LLVM_D_GetRuntimeFunction(llvm::Module* target, const char* name)
llvm::Function* LLVM_D_GetRuntimeFunction(const Loc &loc, llvm::Module* target, const char* name)
{
checkForImplicitGCCall(Loc(), name);
checkForImplicitGCCall(loc, name);
if (!M) {
LLVM_D_InitRuntime();
@ -150,14 +150,14 @@ llvm::Function* LLVM_D_GetRuntimeFunction(llvm::Module* target, const char* name
//////////////////////////////////////////////////////////////////////////////////////////////////
llvm::GlobalVariable* LLVM_D_GetRuntimeGlobal(llvm::Module* target, const char* name)
llvm::GlobalVariable* LLVM_D_GetRuntimeGlobal(Loc& loc, llvm::Module* target, const char* name)
{
LLGlobalVariable* gv = target->getNamedGlobal(name);
if (gv) {
return gv;
}
checkForImplicitGCCall(Loc(), name);
checkForImplicitGCCall(loc, name);
if (!M) {
LLVM_D_InitRuntime();
@ -165,13 +165,13 @@ llvm::GlobalVariable* LLVM_D_GetRuntimeGlobal(llvm::Module* target, const char*
LLGlobalVariable* g = M->getNamedGlobal(name);
if (!g) {
error(Loc(), "Runtime global '%s' was not found", name);
error(loc, "Runtime global '%s' was not found", name);
fatal();
//return NULL;
}
LLPointerType* t = g->getType();
return getOrCreateGlobal(Loc(), *target, t->getElementType(), g->isConstant(),
return getOrCreateGlobal(loc, *target, t->getElementType(), g->isConstant(),
g->getLinkage(), NULL, g->getName());
}

6
gen/runtime.h
View file

@ -21,14 +21,16 @@ namespace llvm
class Module;
}
struct Loc;
// D runtime support helpers
bool LLVM_D_InitRuntime();
void LLVM_D_FreeRuntime();
llvm::Function* LLVM_D_GetRuntimeFunction(llvm::Module* target, const char* name);
llvm::Function* LLVM_D_GetRuntimeFunction(const Loc &loc, llvm::Module* target, const char* name);
llvm::GlobalVariable* LLVM_D_GetRuntimeGlobal(llvm::Module* target, const char* name);
llvm::GlobalVariable* LLVM_D_GetRuntimeGlobal(const Loc &loc, llvm::Module* target, const char* name);
#define _adEq "_adEq2"
#define _adCmp "_adCmp2"

14
gen/statements.cpp
View file

@ -85,7 +85,7 @@ static LLValue* call_string_switch_runtime(llvm::Value* table, Expression* e)
llvm_unreachable("not char/wchar/dchar");
}
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, fname);
llvm::Function* fn = LLVM_D_GetRuntimeFunction(e->loc, gIR->module, fname);
IF_LOG {
Logger::cout() << *table->getType() << '\n';
@ -866,7 +866,7 @@ public:
gIR->DBuilder.EmitFuncEnd(gIR->func()->decl);
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_throw_exception");
llvm::Function* fn = LLVM_D_GetRuntimeFunction(stmt->loc, gIR->module, "_d_throw_exception");
//Logger::cout() << "calling: " << *fn << '\n';
LLValue* arg = DtoBitCast(e->getRVal(), fn->getFunctionType()->getParamType(0));
//Logger::cout() << "arg: " << *arg << '\n';
@ -1550,12 +1550,12 @@ public:
if (stmt->exp)
{
stmt->llsync = stmt->exp->toElem(irs)->getRVal();
DtoEnterMonitor(stmt->llsync);
DtoEnterMonitor(stmt->loc, stmt->llsync);
}
else
{
stmt->llsync = generate_unique_critical_section();
DtoEnterCritical(stmt->llsync);
DtoEnterCritical(stmt->loc, stmt->llsync);
}
// emit body
@ -1570,9 +1570,9 @@ public:
if (irs->scopereturned())
return;
else if (stmt->exp)
DtoLeaveMonitor(stmt->llsync);
DtoLeaveMonitor(stmt->loc, stmt->llsync);
else
DtoLeaveCritical(stmt->llsync);
DtoLeaveCritical(stmt->loc, stmt->llsync);
}
//////////////////////////////////////////////////////////////////////////
@ -1581,7 +1581,7 @@ public:
IF_LOG Logger::println("SwitchErrorStatement::toIR(): %s", stmt->loc.toChars());
LOG_SCOPE;
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_switch_error");
llvm::Function* fn = LLVM_D_GetRuntimeFunction(stmt->loc, gIR->module, "_d_switch_error");
LLValue *moduleInfoSymbol = gIR->func()->decl->getModule()->moduleInfoSymbol();
LLType *moduleInfoType = DtoType(Module::moduleinfo->type);

2
gen/tocall.cpp
View file

@ -81,7 +81,7 @@ DValue* DtoVaArg(Loc& loc, Type* type, Expression* valistArg)
// issue a warning for broken va_arg instruction.
if (global.params.targetTriple.getArch() != llvm::Triple::x86
&& global.params.targetTriple.getArch() != llvm::Triple::ppc64)
warning(Loc(), "%s: va_arg for C variadic functions is probably broken for anything but x86 and ppc64", loc.toChars());
warning(loc, "va_arg for C variadic functions is probably broken for anything but x86 and ppc64");
// done
return new DImValue(type, gIR->ir->CreateVAArg(expelem->getLVal(), llt, "tmp"));
}

34
gen/toir.cpp
View file

@ -476,7 +476,7 @@ DValue* AssignExp::toElem(IRState* p)
DValue* arr = ale->e1->toElem(p);
DVarValue arrval(ale->e1->type, arr->getLVal());
DValue* newlen = e2->toElem(p);
DSliceValue* slice = DtoResizeDynArray(arrval.getType(), &arrval, newlen->getRVal());
DSliceValue* slice = DtoResizeDynArray(loc, arrval.getType(), &arrval, newlen->getRVal());
DtoAssign(loc, &arrval, slice);
return newlen;
}
@ -644,7 +644,7 @@ static void errorOnIllegalArrayOp(Expression* base, Expression* e1, Expression*
//////////////////////////////////////////////////////////////////////////////////////////
static dinteger_t undoStrideMul(const Loc& loc, Type* t, dinteger_t offset)
static dinteger_t undoStrideMul(Loc& loc, Type* t, dinteger_t offset)
{
assert(t->ty == Tpointer);
d_uns64 elemSize = t->nextOf()->size(loc);
@ -1624,7 +1624,7 @@ DValue* DotVarExp::toElem(IRState* p)
{
TypeClass* tc = static_cast<TypeClass*>(e1type);
if (tc->sym->isInterfaceDeclaration() && nonFinal && !tc->sym->isCPPinterface())
passedThis = DtoCastInterfaceToObject(l, NULL)->getRVal();
passedThis = DtoCastInterfaceToObject(loc, l, NULL)->getRVal();
}
LLValue* vthis = l->getRVal();
if (!passedThis) passedThis = vthis;
@ -2148,7 +2148,7 @@ DValue* NewExp::toElem(IRState* p)
} else
{
// default allocator
mem = DtoNew(newtype);
mem = DtoNew(loc, newtype);
}
// init
TypeStruct* ts = static_cast<TypeStruct*>(ntype);
@ -2178,7 +2178,7 @@ DValue* NewExp::toElem(IRState* p)
else
{
// allocate
LLValue* mem = DtoNew(newtype);
LLValue* mem = DtoNew(loc, newtype);
DVarValue tmpvar(newtype, mem);
// default initialize
@ -2207,7 +2207,7 @@ DValue* DeleteExp::toElem(IRState* p)
// simple pointer
if (et->ty == Tpointer)
{
DtoDeleteMemory(dval->isLVal() ? dval->getLVal() : makeLValue(loc, dval));
DtoDeleteMemory(loc, dval->isLVal() ? dval->getLVal() : makeLValue(loc, dval));
}
// class
else if (et->ty == Tclass)
@ -2217,18 +2217,18 @@ DValue* DeleteExp::toElem(IRState* p)
if (tc->sym->isInterfaceDeclaration())
{
LLValue *val = dval->getLVal();
DtoDeleteInterface(val);
DtoDeleteInterface(loc, val);
onstack = true;
}
else if (DVarValue* vv = dval->isVar()) {
if (vv->var && vv->var->onstack) {
DtoFinalizeClass(dval->getRVal());
DtoFinalizeClass(loc, dval->getRVal());
onstack = true;
}
}
if (!onstack) {
LLValue* rval = dval->getRVal();
DtoDeleteClass(rval);
DtoDeleteClass(loc, rval);
}
if (dval->isVar()) {
LLValue* lval = dval->getLVal();
@ -2238,7 +2238,7 @@ DValue* DeleteExp::toElem(IRState* p)
// dyn array
else if (et->ty == Tarray)
{
DtoDeleteArray(dval);
DtoDeleteArray(loc, dval);
if (dval->isLVal())
DtoSetArrayToNull(dval->getLVal());
}
@ -2319,7 +2319,7 @@ DValue* AssertExp::toElem(IRState* p)
!(static_cast<TypeClass*>(condty)->sym->isInterfaceDeclaration()))
{
Logger::println("calling class invariant");
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module,
llvm::Function* fn = LLVM_D_GetRuntimeFunction(loc, gIR->module,
gABI->mangleForLLVM("_D9invariant12_d_invariantFC6ObjectZv", LINKd).c_str());
LLValue* arg = DtoBitCast(cond->getRVal(), fn->getFunctionType()->getParamType(0));
gIR->CreateCallOrInvoke(fn, arg);
@ -2536,7 +2536,7 @@ DValue* DelegateExp::toElem(IRState* p)
if (cd->isInterfaceDeclaration())
{
Logger::println("context type is interface");
src = DtoCastInterfaceToObject(u, ClassDeclaration::object->type);
src = DtoCastInterfaceToObject(loc, u, ClassDeclaration::object->type);
}
}
uval = src->getRVal();
@ -2758,7 +2758,7 @@ DValue* CatExp::toElem(IRState* p)
IF_LOG Logger::print("CatExp::toElem: %s @ %s\n", toChars(), type->toChars());
LOG_SCOPE;
return DtoCatArrays(type, e1, e2);
return DtoCatArrays(loc, type, e1, e2);
}
//////////////////////////////////////////////////////////////////////////////////////////
@ -2780,14 +2780,14 @@ DValue* CatAssignExp::toElem(IRState* p)
{
if (elemtype->ty == Tchar)
// append dchar to char[]
DtoAppendDCharToString(l, e2);
DtoAppendDCharToString(loc, l, e2);
else /*if (elemtype->ty == Twchar)*/
// append dchar to wchar[]
DtoAppendDCharToUnicodeString(l, e2);
DtoAppendDCharToUnicodeString(loc, l, e2);
}
else if (e1type->equals(e2type)) {
// apeend array
DSliceValue* slice = DtoCatAssignArray(l,e2);
DSliceValue* slice = DtoCatAssignArray(loc, l, e2);
DtoAssign(loc, l, slice);
}
else {
@ -3397,7 +3397,7 @@ DValue* AssocArrayLiteralExp::toElem(IRState* p)
Type* indexType = static_cast<TypeAArray*>(aatype)->index;
assert(indexType && vtype);
llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, "_d_assocarrayliteralTX");
llvm::Function* func = LLVM_D_GetRuntimeFunction(loc, gIR->module, "_d_assocarrayliteralTX");
LLFunctionType* funcTy = func->getFunctionType();
LLValue* aaTypeInfo = DtoBitCast(DtoTypeInfoOf(stripModifiers(aatype)),
DtoType(Type::typeinfoassociativearray->type));

2
ir/irclass.cpp
View file

@ -214,7 +214,7 @@ LLConstant * IrAggr::getVtblInit()
else
cd->deprecation("use of %s hidden by %s is deprecated", fd->toPrettyChars(), cd->toChars());
c = DtoBitCast(LLVM_D_GetRuntimeFunction(gIR->module, "_d_hidden_func"), c->getType());
c = DtoBitCast(LLVM_D_GetRuntimeFunction(Loc(), gIR->module, "_d_hidden_func"), c->getType());
break;
}
}

6
ir/irlandingpad.cpp
View file

@ -19,7 +19,7 @@
// creates new landing pad
static llvm::LandingPadInst *createLandingPadInst()
{
llvm::Function* personality_fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_eh_personality");
llvm::Function* personality_fn = LLVM_D_GetRuntimeFunction(Loc(), gIR->module, "_d_eh_personality");
LLType *retType = LLStructType::get(LLType::getInt8PtrTy(gIR->context()),
LLType::getInt32Ty(gIR->context()),
NULL);
@ -98,7 +98,7 @@ void IRLandingPadFinallyStatementInfo::toIR(LLValue *eh_ptr)
llvm::LandingPadInst *collisionLandingPad = createLandingPadInst();
LLValue* collision_eh_ptr = DtoExtractValue(collisionLandingPad, 0);
collisionLandingPad->setCleanup(true);
llvm::Function* collision_fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_eh_handle_collision");
llvm::Function* collision_fn = LLVM_D_GetRuntimeFunction(Loc(), gIR->module, "_d_eh_handle_collision");
gIR->CreateCallOrInvoke2(collision_fn, collision_eh_ptr, eh_ptr);
gIR->ir->CreateUnreachable();
gIR->scope() = IRScope(bb, gIR->scopeend());
@ -222,7 +222,7 @@ void IRLandingPad::constructLandingPad(IRLandingPadScope scope)
gIR->func()->gen->landingPad = get();
// no catch matched and all finallys executed - resume unwind
llvm::Function* unwind_resume_fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_eh_resume_unwind");
llvm::Function* unwind_resume_fn = LLVM_D_GetRuntimeFunction(Loc(), gIR->module, "_d_eh_resume_unwind");
gIR->ir->CreateCall(unwind_resume_fn, eh_ptr);
gIR->ir->CreateUnreachable();