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

Build fix for the latest LLVMContext changes (LLVM r75445)

Browse source 
This shouldn't break the build with older LLVM revs. We include
LLVMContext.h in gen/llvm.h now to make the transition a little bit
easier.
This commit is contained in:
Benjamin Kramer 2009-07-13 12:17:58 +02:00
parent 8576788245
commit 331319dab1
16 changed files with 36 additions and 38 deletions
Download patch file Download diff file Expand all files Collapse all files

2
gen/aa.cpp
View file

@ -105,7 +105,7 @@ DValue* DtoAAIndex(Loc& loc, Type* type, DValue* aa, DValue* key, bool lvalue)
llvm::BasicBlock* failbb = llvm::BasicBlock::Create("aaboundscheckfail", gIR->topfunc(), oldend);
llvm::BasicBlock* okbb = llvm::BasicBlock::Create("aaboundsok", gIR->topfunc(), oldend);
LLValue* nullaa = LLConstant::getNullValue(ret->getType());
LLValue* nullaa = llvm::getGlobalContext().getNullValue(ret->getType());
LLValue* cond = gIR->ir->CreateICmpNE(nullaa, ret, "aaboundscheck");
gIR->ir->CreateCondBr(cond, okbb, failbb);

2
gen/arrays.cpp
View file

@ -60,7 +60,7 @@ void DtoSetArrayToNull(LLValue* v)
assert(isaPointer(v));
const LLType* t = v->getType()->getContainedType(0);
DtoStore(LLConstant::getNullValue(t), v);
DtoStore(llvm::getGlobalContext().getNullValue(t), v);
}
//////////////////////////////////////////////////////////////////////////////////////////

10
gen/classes.cpp
View file

@ -211,7 +211,7 @@ void DtoInitClass(TypeClass* tc, LLValue* dst)
// monitor always defaults to zero
tmp = DtoGEPi(dst,0,1,"monitor");
val = llvm::Constant::getNullValue(tmp->getType()->getContainedType(0));
val = llvm::getGlobalContext().getNullValue(tmp->getType()->getContainedType(0));
DtoStore(val, tmp);
// done?
@ -262,7 +262,7 @@ DValue* DtoCastClass(DValue* val, Type* _to)
else if (to->ty == Tbool) {
IF_LOG Logger::println("to bool");
LLValue* llval = val->getRVal();
LLValue* zero = LLConstant::getNullValue(llval->getType());
LLValue* zero = llvm::getGlobalContext().getNullValue(llval->getType());
return new DImValue(_to, gIR->ir->CreateICmpNE(llval, zero, "tmp"));
}
// class -> integer
@ -326,8 +326,8 @@ DValue* DtoCastClass(DValue* val, Type* _to)
// Sure we could have jumped over the code above in this case, but
// it's just a GEP and (maybe) a pointer-to-pointer BitCast, so it
// should be pretty cheap and perfectly safe even if the original was null.
LLValue* isNull = gIR->ir->CreateICmpEQ(orig, LLConstant::getNullValue(orig->getType()), ".nullcheck");
v = gIR->ir->CreateSelect(isNull, LLConstant::getNullValue(ifType), v, ".interface");
LLValue* isNull = gIR->ir->CreateICmpEQ(orig, llvm::getGlobalContext().getNullValue(orig->getType()), ".nullcheck");
v = gIR->ir->CreateSelect(isNull, llvm::getGlobalContext().getNullValue(ifType), v, ".interface");
// return r-value
return new DImValue(_to, v);
@ -602,7 +602,7 @@ static LLConstant* build_offti_array(ClassDeclaration* cd, const LLType* arrayT)
LLConstant* ptr;
if (nvars == 0)
return LLConstant::getNullValue( arrayT );
return llvm::getGlobalContext().getNullValue( arrayT );
// array type
const llvm::ArrayType* arrTy = llvm::ArrayType::get(arrayInits[0]->getType(), nvars);

4
gen/complex.cpp
View file

@ -111,9 +111,9 @@ DValue* DtoComplex(Loc& loc, Type* to, DValue* val)
DtoGetComplexParts(loc, to, val, re, im);
if(!re)
re = LLConstant::getNullValue(DtoType(baserety));
re = llvm::getGlobalContext().getNullValue(DtoType(baserety));
if(!im)
im = LLConstant::getNullValue(DtoType(baseimty));
im = llvm::getGlobalContext().getNullValue(DtoType(baseimty));
LLValue* res = DtoAggrPair(complexTy, re, im);

2
gen/functions.cpp
View file

@ -811,7 +811,7 @@ void DtoDefineFunction(FuncDeclaration* fd)
}
}
else
llvm::ReturnInst::Create(llvm::Constant::getNullValue(func->getReturnType()), bb);
llvm::ReturnInst::Create(llvm::getGlobalContext().getNullValue(func->getReturnType()), bb);
}
// std::cout << *func << std::endl;

1
gen/llvm.h
View file

@ -11,6 +11,7 @@
#include "llvm/Module.h"
#include "llvm/Value.h"
#include "llvm/Attributes.h"
#include "llvm/LLVMContext.h"
#include "llvm/Target/TargetData.h"

12
gen/llvmhelpers.cpp
View file

@ -464,13 +464,13 @@ DValue* DtoNullValue(Type* type)
if (basetype->iscomplex())
{
const LLType* basefp = DtoComplexBaseType(basetype);
LLValue* res = DtoAggrPair(DtoType(type), LLConstant::getNullValue(basefp), LLConstant::getNullValue(basefp));
LLValue* res = DtoAggrPair(DtoType(type), llvm::getGlobalContext().getNullValue(basefp), llvm::getGlobalContext().getNullValue(basefp));
return new DImValue(type, res);
}
// integer, floating, pointer and class have no special representation
else if (basetype->isintegral() || basetype->isfloating() || basety == Tpointer || basety == Tclass)
{
return new DConstValue(type, LLConstant::getNullValue(lltype));
return new DConstValue(type, llvm::getGlobalContext().getNullValue(lltype));
}
// dynamic array
else if (basety == Tarray)
@ -482,7 +482,7 @@ DValue* DtoNullValue(Type* type)
// delegate
else if (basety == Tdelegate)
{
return new DNullValue(type, LLConstant::getNullValue(lltype));
return new DNullValue(type, llvm::getGlobalContext().getNullValue(lltype));
}
// unknown
@ -577,7 +577,7 @@ DValue* DtoCastPtr(Loc& loc, DValue* val, Type* to)
}
else if (totype->ty == Tbool) {
LLValue* src = val->getRVal();
LLValue* zero = LLConstant::getNullValue(src->getType());
LLValue* zero = llvm::getGlobalContext().getNullValue(src->getType());
rval = gIR->ir->CreateICmpNE(src, zero, "tmp");
}
else if (totype->isintegral()) {
@ -609,7 +609,7 @@ DValue* DtoCastFloat(Loc& loc, DValue* val, Type* to)
if (totype->ty == Tbool) {
rval = val->getRVal();
LLValue* zero = LLConstant::getNullValue(rval->getType());
LLValue* zero = llvm::getGlobalContext().getNullValue(rval->getType());
rval = gIR->ir->CreateFCmpUNE(rval, zero, "tmp");
}
else if (totype->iscomplex()) {
@ -1124,7 +1124,7 @@ LLConstant* DtoConstInitializer(Loc loc, Type* type, Initializer* init)
{
Logger::println("const void initializer");
const LLType* ty = DtoType(type);
_init = llvm::Constant::getNullValue(ty);
_init = llvm::getGlobalContext().getNullValue(ty);
}
else {
Logger::println("unsupported const initializer: %s", init->toChars());

1
gen/main.cpp
View file

@ -7,7 +7,6 @@
#include "gen/llvm-version.h"
#include "llvm/LinkAllVMCore.h"
#include "llvm/Linker.h"
#include "llvm/LLVMContext.h"
#include "llvm/System/Signals.h"
#include "llvm/Target/SubtargetFeature.h"
#include "llvm/Target/TargetMachine.h"

1
gen/runtime.cpp
View file

@ -1,6 +1,5 @@
#include "gen/llvm.h"
#include "gen/llvm-version.h"
#include "llvm/LLVMContext.h"
#include "llvm/Module.h"
#include "llvm/Attributes.h"
#include "llvm/Bitcode/ReaderWriter.h"

4
gen/statements.cpp
View file

@ -114,7 +114,7 @@ void ReturnStatement::toIR(IRState* p)
// and return 0 instead
// if we're not in main, just bitcast
if (p->topfunc() == p->mainFunc)
v = llvm::Constant::getNullValue(p->mainFunc->getReturnType());
v = llvm::getGlobalContext().getNullValue(p->mainFunc->getReturnType());
else
v = gIR->ir->CreateBitCast(v, p->topfunc()->getReturnType(), "tmp");
@ -1380,7 +1380,7 @@ void WithStatement::toIR(IRState* p)
static LLConstant* generate_unique_critical_section()
{
const LLType* Mty = DtoMutexType();
return new llvm::GlobalVariable(*gIR->module, Mty, false, llvm::GlobalValue::InternalLinkage, LLConstant::getNullValue(Mty), ".uniqueCS");
return new llvm::GlobalVariable(*gIR->module, Mty, false, llvm::GlobalValue::InternalLinkage, llvm::getGlobalContext().getNullValue(Mty), ".uniqueCS");
}
void SynchronizedStatement::toIR(IRState* p)

8
gen/structs.cpp
View file

@ -162,22 +162,22 @@ size_t add_zeros(std::vector<llvm::Value*>& values, size_t diff)
{
if (is64 && diff % 8 == 0)
{
values.push_back(llvm::Constant::getNullValue(llvm::Type::Int64Ty));
values.push_back(llvm::getGlobalContext().getNullValue(llvm::Type::Int64Ty));
diff -= 8;
}
else if (diff % 4 == 0)
{
values.push_back(llvm::Constant::getNullValue(llvm::Type::Int32Ty));
values.push_back(llvm::getGlobalContext().getNullValue(llvm::Type::Int32Ty));
diff -= 4;
}
else if (diff % 2 == 0)
{
values.push_back(llvm::Constant::getNullValue(llvm::Type::Int16Ty));
values.push_back(llvm::getGlobalContext().getNullValue(llvm::Type::Int16Ty));
diff -= 2;
}
else
{
values.push_back(llvm::Constant::getNullValue(llvm::Type::Int8Ty));
values.push_back(llvm::getGlobalContext().getNullValue(llvm::Type::Int8Ty));
diff -= 1;
}
}

4
gen/todebug.cpp
View file

@ -19,7 +19,7 @@
using namespace llvm::dwarf;
#define DBG_NULL ( LLConstant::getNullValue(DBG_TYPE) )
#define DBG_NULL ( llvm::getGlobalContext().getNullValue(DBG_TYPE) )
#define DBG_TYPE ( getPtrToType(llvm::StructType::get(NULL,NULL)) )
#define DBG_CAST(X) ( llvm::ConstantExpr::getBitCast(X, DBG_TYPE) )
@ -297,7 +297,7 @@ static llvm::DICompositeType dwarfCompositeType(Type* type, llvm::DICompileUnit
std::vector<LLConstant*> initvals(11);
initvals[0] = DBG_TAG(DW_TAG_structure_type);
for (int i = 1; i < initvals.size(); ++i)
initvals[i] = LLConstant::getNullValue(getDwarfCompositeTypeType()->getContainedType(i));
initvals[i] = llvm::getGlobalContext().getNullValue(getDwarfCompositeTypeType()->getContainedType(i));
gv->setInitializer(LLConstantStruct::get(getDwarfCompositeTypeType(), initvals));
ir->diCompositeType = llvm::DICompositeType(gv);

8
gen/toir.cpp
View file

@ -341,7 +341,7 @@ LLConstant* NullExp::toConstElem(IRState* p)
return llvm::ConstantAggregateZero::get(t);
}
else {
return llvm::Constant::getNullValue(t);
return llvm::getGlobalContext().getNullValue(t);
}
assert(0);
return NULL;
@ -1656,7 +1656,7 @@ DValue* DeleteExp::toElem(IRState* p)
LLValue* rval = dval->getRVal();
DtoDeleteMemory(rval);
if (dval->isVar())
DtoStore(llvm::Constant::getNullValue(rval->getType()), dval->getLVal());
DtoStore(llvm::getGlobalContext().getNullValue(rval->getType()), dval->getLVal());
}
// class
else if (et->ty == Tclass)
@ -1680,7 +1680,7 @@ DValue* DeleteExp::toElem(IRState* p)
}
if (dval->isVar()) {
LLValue* lval = dval->getLVal();
DtoStore(llvm::Constant::getNullValue(lval->getType()->getContainedType(0)), lval);
DtoStore(llvm::getGlobalContext().getNullValue(lval->getType()->getContainedType(0)), lval);
}
}
// dyn array
@ -2547,7 +2547,7 @@ DValue* AssocArrayLiteralExp::toElem(IRState* p)
// it should be possible to avoid the temporary in some cases
LLValue* tmp = DtoAlloca(type,"aaliteral");
DValue* aa = new DVarValue(type, tmp);
DtoStore(LLConstant::getNullValue(DtoType(type)), tmp);
DtoStore(llvm::getGlobalContext().getNullValue(DtoType(type)), tmp);
const size_t n = keys->dim;
for (size_t i=0; i<n; ++i)

4
gen/tollvm.cpp
View file

@ -213,7 +213,7 @@ LLValue* DtoDelegateEquals(TOK op, LLValue* lhs, LLValue* rhs)
llvm::Value *b1, *b2;
if (rhs == NULL)
{
rhs = LLConstant::getNullValue(lhs->getType());
rhs = llvm::getGlobalContext().getNullValue(lhs->getType());
}
LLValue* l = gIR->ir->CreateExtractValue(lhs, 0);
@ -741,7 +741,7 @@ llvm::ConstantPointerNull* getNullPtr(const LLType* t)
LLConstant* getNullValue(const LLType* t)
{
return LLConstant::getNullValue(t);
return llvm::getGlobalContext().getNullValue(t);
}
//////////////////////////////////////////////////////////////////////////////////////////

3
gen/toobj.cpp
View file

@ -14,7 +14,6 @@
#include "gen/llvm-version.h"
#include "llvm/Analysis/Verifier.h"
#include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/LLVMContext.h"
#include "llvm/Module.h"
#include "llvm/ModuleProvider.h"
#include "llvm/PassManager.h"
@ -555,7 +554,7 @@ static LLFunction* build_module_reference_and_ctor(LLConstant* moduleinfo)
// provide the default initializer
const LLStructType* modulerefTy = DtoModuleReferenceType();
std::vector<LLConstant*> mrefvalues;
mrefvalues.push_back(LLConstant::getNullValue(modulerefTy->getContainedType(0)));
mrefvalues.push_back(llvm::getGlobalContext().getNullValue(modulerefTy->getContainedType(0)));
mrefvalues.push_back(llvm::ConstantExpr::getBitCast(moduleinfo, modulerefTy->getContainedType(1)));
LLConstant* thismrefinit = LLConstantStruct::get(modulerefTy, mrefvalues);

8
ir/irstruct.cpp
View file

@ -117,22 +117,22 @@ size_t add_zeros(std::vector<llvm::Constant*>& constants, size_t diff)
{
if (global.params.is64bit && diff % 8 == 0)
{
constants.push_back(llvm::Constant::getNullValue(llvm::Type::Int64Ty));
constants.push_back(llvm::getGlobalContext().getNullValue(llvm::Type::Int64Ty));
diff -= 8;
}
else if (diff % 4 == 0)
{
constants.push_back(llvm::Constant::getNullValue(llvm::Type::Int32Ty));
constants.push_back(llvm::getGlobalContext().getNullValue(llvm::Type::Int32Ty));
diff -= 4;
}
else if (diff % 2 == 0)
{
constants.push_back(llvm::Constant::getNullValue(llvm::Type::Int16Ty));
constants.push_back(llvm::getGlobalContext().getNullValue(llvm::Type::Int16Ty));
diff -= 2;
}
else
{
constants.push_back(llvm::Constant::getNullValue(llvm::Type::Int8Ty));
constants.push_back(llvm::getGlobalContext().getNullValue(llvm::Type::Int8Ty));
diff -= 1;
}
}