From 331319dab1c3b36fd1dd5569df43875bb212d357 Mon Sep 17 00:00:00 2001 From: Benjamin Kramer Date: Mon, 13 Jul 2009 12:17:58 +0200 Subject: [PATCH] Build fix for the latest LLVMContext changes (LLVM r75445) 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. --- gen/aa.cpp | 2 +- gen/arrays.cpp | 2 +- gen/classes.cpp | 10 +++++----- gen/complex.cpp | 4 ++-- gen/functions.cpp | 2 +- gen/llvm.h | 1 + gen/llvmhelpers.cpp | 12 ++++++------ gen/main.cpp | 1 - gen/runtime.cpp | 1 - gen/statements.cpp | 4 ++-- gen/structs.cpp | 8 ++++---- gen/todebug.cpp | 4 ++-- gen/toir.cpp | 8 ++++---- gen/tollvm.cpp | 4 ++-- gen/toobj.cpp | 3 +-- ir/irstruct.cpp | 8 ++++---- 16 files changed, 36 insertions(+), 38 deletions(-) diff --git a/gen/aa.cpp b/gen/aa.cpp index b979c128..4b735d76 100644 --- a/gen/aa.cpp +++ b/gen/aa.cpp @@ -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); diff --git a/gen/arrays.cpp b/gen/arrays.cpp index 3061242a..d367941b 100644 --- a/gen/arrays.cpp +++ b/gen/arrays.cpp @@ -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); } ////////////////////////////////////////////////////////////////////////////////////////// diff --git a/gen/classes.cpp b/gen/classes.cpp index 96789509..350726f4 100644 --- a/gen/classes.cpp +++ b/gen/classes.cpp @@ -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); diff --git a/gen/complex.cpp b/gen/complex.cpp index a1daa4e6..42b18fc0 100644 --- a/gen/complex.cpp +++ b/gen/complex.cpp @@ -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); diff --git a/gen/functions.cpp b/gen/functions.cpp index 703c894c..9683d212 100644 --- a/gen/functions.cpp +++ b/gen/functions.cpp @@ -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; diff --git a/gen/llvm.h b/gen/llvm.h index 1221c055..0332cf87 100644 --- a/gen/llvm.h +++ b/gen/llvm.h @@ -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" diff --git a/gen/llvmhelpers.cpp b/gen/llvmhelpers.cpp index fa4da945..2a6476e4 100644 --- a/gen/llvmhelpers.cpp +++ b/gen/llvmhelpers.cpp @@ -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()); diff --git a/gen/main.cpp b/gen/main.cpp index 6079a436..794cf8e1 100644 --- a/gen/main.cpp +++ b/gen/main.cpp @@ -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" diff --git a/gen/runtime.cpp b/gen/runtime.cpp index a18b8890..7109f8fe 100644 --- a/gen/runtime.cpp +++ b/gen/runtime.cpp @@ -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" diff --git a/gen/statements.cpp b/gen/statements.cpp index f314c8db..9a2e21b5 100644 --- a/gen/statements.cpp +++ b/gen/statements.cpp @@ -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) diff --git a/gen/structs.cpp b/gen/structs.cpp index bafac183..977261dc 100644 --- a/gen/structs.cpp +++ b/gen/structs.cpp @@ -162,22 +162,22 @@ size_t add_zeros(std::vector& 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; } } diff --git a/gen/todebug.cpp b/gen/todebug.cpp index 325e46d4..90a6446a 100644 --- a/gen/todebug.cpp +++ b/gen/todebug.cpp @@ -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 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); diff --git a/gen/toir.cpp b/gen/toir.cpp index 1c9ca70b..d34c2807 100644 --- a/gen/toir.cpp +++ b/gen/toir.cpp @@ -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; igetType()); + 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); } ////////////////////////////////////////////////////////////////////////////////////////// diff --git a/gen/toobj.cpp b/gen/toobj.cpp index 8d4ee5d6..055e0a60 100644 --- a/gen/toobj.cpp +++ b/gen/toobj.cpp @@ -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 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); diff --git a/ir/irstruct.cpp b/ir/irstruct.cpp index 1ad44aad..98f24ddd 100644 --- a/ir/irstruct.cpp +++ b/ir/irstruct.cpp @@ -117,22 +117,22 @@ size_t add_zeros(std::vector& 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; } }