diff options
Diffstat (limited to 'lib')
25 files changed, 492 insertions, 428 deletions
diff --git a/lib/Analysis/DebugInfo.cpp b/lib/Analysis/DebugInfo.cpp index 491cc3f202..437ff03b32 100644 --- a/lib/Analysis/DebugInfo.cpp +++ b/lib/Analysis/DebugInfo.cpp @@ -463,7 +463,7 @@ DIFactory::DIFactory(Module &m) /// getCastToEmpty - Return this descriptor as a Constant* with type '{}*'. /// This is only valid when the descriptor is non-null. Constant *DIFactory::getCastToEmpty(DIDescriptor D) { - if (D.isNull()) return Constant::getNullValue(EmptyStructPtr); + if (D.isNull()) return VMContext.getNullValue(EmptyStructPtr); return VMContext.getConstantExprBitCast(D.getGV(), EmptyStructPtr); } diff --git a/lib/Analysis/IPA/Andersens.cpp b/lib/Analysis/IPA/Andersens.cpp index 3f1dcb75b1..91aaf0670a 100644 --- a/lib/Analysis/IPA/Andersens.cpp +++ b/lib/Analysis/IPA/Andersens.cpp @@ -693,7 +693,7 @@ void Andersens::getMustAliases(Value *P, std::vector<Value*> &RetVals) { // If the object in the points-to set is the null object, then the null // pointer is a must alias. if (Pointee == &GraphNodes[NullObject]) - RetVals.push_back(Constant::getNullValue(P->getType())); + RetVals.push_back(Context->getNullValue(P->getType())); } } AliasAnalysis::getMustAliases(P, RetVals); diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp index a167792024..fc7d286aaf 100644 --- a/lib/Analysis/ScalarEvolution.cpp +++ b/lib/Analysis/ScalarEvolution.cpp @@ -2084,7 +2084,8 @@ const SCEV *ScalarEvolution::getIntegerSCEV(int Val, const Type *Ty) { /// const SCEV *ScalarEvolution::getNegativeSCEV(const SCEV *V) { if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V)) - return getConstant(cast<ConstantInt>(ConstantExpr::getNeg(VC->getValue()))); + return getConstant( + cast<ConstantInt>(Context->getConstantExprNeg(VC->getValue()))); const Type *Ty = V->getType(); Ty = getEffectiveSCEVType(Ty); @@ -3284,7 +3285,7 @@ EvaluateConstantChrecAtConstant(const SCEVAddRecExpr *AddRec, ConstantInt *C, /// the addressed element of the initializer or null if the index expression is /// invalid. static Constant * -GetAddressedElementFromGlobal(GlobalVariable *GV, +GetAddressedElementFromGlobal(LLVMContext *Context, GlobalVariable *GV, const std::vector<ConstantInt*> &Indices) { Constant *Init = GV->getInitializer(); for (unsigned i = 0, e = Indices.size(); i != e; ++i) { @@ -3298,10 +3299,10 @@ GetAddressedElementFromGlobal(GlobalVariable *GV, } else if (isa<ConstantAggregateZero>(Init)) { if (const StructType *STy = dyn_cast<StructType>(Init->getType())) { assert(Idx < STy->getNumElements() && "Bad struct index!"); - Init = Constant::getNullValue(STy->getElementType(Idx)); + Init = Context->getNullValue(STy->getElementType(Idx)); } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Init->getType())) { if (Idx >= ATy->getNumElements()) return 0; // Bogus program - Init = Constant::getNullValue(ATy->getElementType()); + Init = Context->getNullValue(ATy->getElementType()); } else { LLVM_UNREACHABLE("Unknown constant aggregate type!"); } @@ -3372,7 +3373,7 @@ ScalarEvolution::ComputeLoadConstantCompareBackedgeTakenCount( // Form the GEP offset. Indexes[VarIdxNum] = Val; - Constant *Result = GetAddressedElementFromGlobal(GV, Indexes); + Constant *Result = GetAddressedElementFromGlobal(Context, GV, Indexes); if (Result == 0) break; // Cannot compute! // Evaluate the condition for this iteration. diff --git a/lib/CodeGen/IntrinsicLowering.cpp b/lib/CodeGen/IntrinsicLowering.cpp index 914d703e85..9e6bcd83f3 100644 --- a/lib/CodeGen/IntrinsicLowering.cpp +++ b/lib/CodeGen/IntrinsicLowering.cpp @@ -315,6 +315,7 @@ static void ReplaceFPIntrinsicWithCall(CallInst *CI, const char *Fname, void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) { IRBuilder<> Builder(CI->getParent(), CI); + LLVMContext *Context = CI->getParent()->getContext(); Function *Callee = CI->getCalledFunction(); assert(Callee && "Cannot lower an indirect call!"); @@ -340,7 +341,7 @@ void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) { } case Intrinsic::sigsetjmp: if (CI->getType() != Type::VoidTy) - CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); + CI->replaceAllUsesWith(Context->getNullValue(CI->getType())); break; case Intrinsic::longjmp: { @@ -387,7 +388,7 @@ void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) { "save" : "restore") << " intrinsic.\n"; Warned = true; if (Callee->getIntrinsicID() == Intrinsic::stacksave) - CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); + CI->replaceAllUsesWith(Context->getNullValue(CI->getType())); break; } @@ -422,7 +423,7 @@ void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) { case Intrinsic::eh_exception: case Intrinsic::eh_selector_i32: case Intrinsic::eh_selector_i64: - CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); + CI->replaceAllUsesWith(Context->getNullValue(CI->getType())); break; case Intrinsic::eh_typeid_for_i32: diff --git a/lib/CodeGen/MachOWriter.cpp b/lib/CodeGen/MachOWriter.cpp index 7542d9ed10..35f71075cc 100644 --- a/lib/CodeGen/MachOWriter.cpp +++ b/lib/CodeGen/MachOWriter.cpp @@ -123,7 +123,7 @@ bool MachOWriter::doFinalization(Module &M) { // getConstSection - Get constant section for Constant 'C' MachOSection *MachOWriter::getConstSection(Constant *C) { const ConstantArray *CVA = dyn_cast<ConstantArray>(C); - if (CVA && CVA->isCString()) + if (CVA && CVA->isCString(*Context)) return getSection("__TEXT", "__cstring", MachOSection::S_CSTRING_LITERALS); diff --git a/lib/CodeGen/SelectionDAG/FastISel.cpp b/lib/CodeGen/SelectionDAG/FastISel.cpp index cd2d5ac8ec..adb4d729e6 100644 --- a/lib/CodeGen/SelectionDAG/FastISel.cpp +++ b/lib/CodeGen/SelectionDAG/FastISel.cpp @@ -92,7 +92,7 @@ unsigned FastISel::getRegForValue(Value *V) { } else if (isa<ConstantPointerNull>(V)) { // Translate this as an integer zero so that it can be // local-CSE'd with actual integer zeros. - Reg = getRegForValue(Constant::getNullValue(TD.getIntPtrType())); + Reg = getRegForValue(Context->getNullValue(TD.getIntPtrType())); } else if (ConstantFP *CF = dyn_cast<ConstantFP>(V)) { Reg = FastEmit_f(VT, VT, ISD::ConstantFP, CF); @@ -480,7 +480,7 @@ bool FastISel::SelectCall(User *I) { UpdateValueMap(I, ResultReg); } else { unsigned ResultReg = - getRegForValue(Constant::getNullValue(I->getType())); + getRegForValue(Context->getNullValue(I->getType())); UpdateValueMap(I, ResultReg); } return true; @@ -753,7 +753,8 @@ FastISel::FastISel(MachineFunction &mf, TM(MF.getTarget()), TD(*TM.getTargetData()), TII(*TM.getInstrInfo()), - TLI(*TM.getTargetLowering()) { + TLI(*TM.getTargetLowering()), + Context(mf.getFunction()->getContext()) { } FastISel::~FastISel() {} diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp index 63aa7cfe7c..ef71a62f14 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp @@ -2139,7 +2139,7 @@ void SelectionDAGLowering::visitFSub(User &I) { const VectorType *DestTy = cast<VectorType>(I.getType()); const Type *ElTy = DestTy->getElementType(); unsigned VL = DestTy->getNumElements(); - std::vector<Constant*> NZ(VL, ConstantFP::getNegativeZero(ElTy)); + std::vector<Constant*> NZ(VL, Context->getConstantFPNegativeZero(ElTy)); Constant *CNZ = ConstantVector::get(&NZ[0], NZ.size()); if (CV == CNZ) { SDValue Op2 = getValue(I.getOperand(1)); @@ -2150,7 +2150,8 @@ void SelectionDAGLowering::visitFSub(User &I) { } } if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0))) - if (CFP->isExactlyValue(ConstantFP::getNegativeZero(Ty)->getValueAPF())) { + if (CFP->isExactlyValue( + Context->getConstantFPNegativeZero(Ty)->getValueAPF())) { SDValue Op2 = getValue(I.getOperand(1)); setValue(&I, DAG.getNode(ISD::FNEG, getCurDebugLoc(), Op2.getValueType(), Op2)); @@ -2398,7 +2399,7 @@ void SelectionDAGLowering::visitShuffleVector(User &I) { // Convert the ConstantVector mask operand into an array of ints, with -1 // representing undef values. SmallVector<Constant*, 8> MaskElts; - cast<Constant>(I.getOperand(2))->getVectorElements(MaskElts); + cast<Constant>(I.getOperand(2))->getVectorElements(*Context, MaskElts); unsigned MaskNumElts = MaskElts.size(); for (unsigned i = 0; i != MaskNumElts; ++i) { if (isa<UndefValue>(MaskElts[i])) diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h b/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h index 6039ef56f2..deb8855690 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h +++ b/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h @@ -15,6 +15,7 @@ #define SELECTIONDAGBUILD_H #include "llvm/Constants.h" +#include "llvm/CodeGen/SelectionDAG.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/DenseMap.h" #ifndef NDEBUG @@ -362,11 +363,14 @@ public: /// GFI - Garbage collection metadata for the function. GCFunctionInfo *GFI; + LLVMContext *Context; + SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, FunctionLoweringInfo &funcinfo, CodeGenOpt::Level ol) : CurDebugLoc(DebugLoc::getUnknownLoc()), - TLI(tli), DAG(dag), FuncInfo(funcinfo), OptLevel(ol) { + TLI(tli), DAG(dag), FuncInfo(funcinfo), OptLevel(ol), + Context(dag.getContext()) { } void init(GCFunctionInfo *gfi, AliasAnalysis &aa); diff --git a/lib/CodeGen/ShadowStackGC.cpp b/lib/CodeGen/ShadowStackGC.cpp index 6ba1243ce1..13fa758c24 100644 --- a/lib/CodeGen/ShadowStackGC.cpp +++ b/lib/CodeGen/ShadowStackGC.cpp @@ -293,10 +293,10 @@ bool ShadowStackGC::initializeCustomLowering(Module &M) { // linkage! Head = new GlobalVariable(M, StackEntryPtrTy, false, GlobalValue::LinkOnceAnyLinkage, - Constant::getNullValue(StackEntryPtrTy), + M.getContext().getNullValue(StackEntryPtrTy), "llvm_gc_root_chain"); } else if (Head->hasExternalLinkage() && Head->isDeclaration()) { - Head->setInitializer(Constant::getNullValue(StackEntryPtrTy)); + Head->setInitializer(M.getContext().getNullValue(StackEntryPtrTy)); Head->setLinkage(GlobalValue::LinkOnceAnyLinkage); } diff --git a/lib/CodeGen/UnreachableBlockElim.cpp b/lib/CodeGen/UnreachableBlockElim.cpp index c3b213cebe..003470d954 100644 --- a/lib/CodeGen/UnreachableBlockElim.cpp +++ b/lib/CodeGen/UnreachableBlockElim.cpp @@ -68,7 +68,7 @@ bool UnreachableBlockElim::runOnFunction(Function &F) { BasicBlock *BB = I; DeadBlocks.push_back(BB); while (PHINode *PN = dyn_cast<PHINode>(BB->begin())) { - PN->replaceAllUsesWith(Constant::getNullValue(PN->getType())); + PN->replaceAllUsesWith(Context->getNullValue(PN->getType())); BB->getInstList().pop_front(); } for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI) diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp index f922146cd0..a403f2e9f1 100644 --- a/lib/Target/CBackend/CBackend.cpp +++ b/lib/Target/CBackend/CBackend.cpp @@ -1239,7 +1239,7 @@ void CWriter::printConstant(Constant *CPV, bool Static) { Out << '{'; if (AT->getNumElements()) { Out << ' '; - Constant *CZ = Constant::getNullValue(AT->getElementType()); + Constant *CZ = Context->getNullValue(AT->getElementType()); printConstant(CZ, Static); for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) { Out << ", "; @@ -1264,7 +1264,7 @@ void CWriter::printConstant(Constant *CPV, bool Static) { assert(isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)); const VectorType *VT = cast<VectorType>(CPV->getType()); Out << "{ "; - Constant *CZ = Constant::getNullValue(VT->getElementType()); + Constant *CZ = Context->getNullValue(VT->getElementType()); printConstant(CZ, Static); for (unsigned i = 1, e = VT->getNumElements(); i != e; ++i) { Out << ", "; @@ -1286,10 +1286,10 @@ void CWriter::printConstant(Constant *CPV, bool Static) { Out << '{'; if (ST->getNumElements()) { Out << ' '; - printConstant(Constant::getNullValue(ST->getElementType(0)), Static); + printConstant(Context->getNullValue(ST->getElementType(0)), Static); for (unsigned i = 1, e = ST->getNumElements(); i != e; ++i) { Out << ", "; - printConstant(Constant::getNullValue(ST->getElementType(i)), Static); + printConstant(Context->getNullValue(ST->getElementType(i)), Static); } } Out << " }"; @@ -2621,11 +2621,11 @@ void CWriter::visitBinaryOperator(Instruction &I) { // If this is a negation operation, print it out as such. For FP, we don't // want to print "-0.0 - X". - if (BinaryOperator::isNeg(&I)) { + if (BinaryOperator::isNeg(*Context, &I)) { Out << "-("; writeOperand(BinaryOperator::getNegArgument(cast<BinaryOperator>(&I))); Out << ")"; - } else if (BinaryOperator::isFNeg(&I)) { + } else if (BinaryOperator::isFNeg(*Context, &I)) { Out << "-("; writeOperand(BinaryOperator::getFNegArgument(cast<BinaryOperator>(&I))); Out << ")"; diff --git a/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp b/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp index 17c7640e36..89e9426f24 100644 --- a/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp +++ b/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp @@ -541,7 +541,7 @@ printModuleLevelGV(const GlobalVariable* GVar) { // Fall Through case GlobalValue::PrivateLinkage: case GlobalValue::InternalLinkage: - if (CVA && CVA->isCString()) + if (CVA && CVA->isCString(GVar->getParent()->getContext())) printSizeAndType = false; break; case GlobalValue::GhostLinkage: diff --git a/lib/Target/Mips/MipsISelLowering.cpp b/lib/Target/Mips/MipsISelLowering.cpp index f3fa17938b..3727918eac 100644 --- a/lib/Target/Mips/MipsISelLowering.cpp +++ b/lib/Target/Mips/MipsISelLowering.cpp @@ -227,7 +227,7 @@ bool MipsTargetLowering::IsGlobalInSmallSection(GlobalValue *GV) if (GVA->hasInitializer() && GV->hasLocalLinkage()) { Constant *C = GVA->getInitializer(); const ConstantArray *CVA = dyn_cast<ConstantArray>(C); - if (CVA && CVA->isCString()) + if (CVA && CVA->isCString(GV->getParent()->getContext())) return false; } diff --git a/lib/Target/TargetAsmInfo.cpp b/lib/Target/TargetAsmInfo.cpp index 782e7b4d87..4fbe1ae55e 100644 --- a/lib/Target/TargetAsmInfo.cpp +++ b/lib/Target/TargetAsmInfo.cpp @@ -170,11 +170,11 @@ static bool isSuitableForBSS(const GlobalVariable *GV) { return (C->isNullValue() && !GV->isConstant() && !NoZerosInBSS); } -static bool isConstantString(const Constant *C) { +static bool isConstantString(LLVMContext &Context, const Constant *C) { // First check: is we have constant array of i8 terminated with zero const ConstantArray *CVA = dyn_cast<ConstantArray>(C); // Check, if initializer is a null-terminated string - if (CVA && CVA->isCString()) + if (CVA && CVA->isCString(Context)) return true; // Another possibility: [1 x i8] zeroinitializer @@ -229,7 +229,7 @@ TargetAsmInfo::SectionKindForGlobal(const GlobalValue *GV) const { } } else { // Check, if initializer is a null-terminated string - if (isConstantString(C)) + if (isConstantString(GV->getParent()->getContext(), C)) return SectionKind::RODataMergeStr; else return SectionKind::RODataMergeConst; diff --git a/lib/Target/X86/X86FastISel.cpp b/lib/Target/X86/X86FastISel.cpp index feb3d4c72e..2b3304d19c 100644 --- a/lib/Target/X86/X86FastISel.cpp +++ b/lib/Target/X86/X86FastISel.cpp @@ -272,7 +272,7 @@ bool X86FastISel::X86FastEmitStore(MVT VT, Value *Val, const X86AddressMode &AM) { // Handle 'null' like i32/i64 0. if (isa<ConstantPointerNull>(Val)) - Val = Constant::getNullValue(TD.getIntPtrType()); + Val = Context->getNullValue(TD.getIntPtrType()); // If this is a store of a simple constant, fold the constant into the store. if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) { @@ -672,7 +672,7 @@ bool X86FastISel::X86FastEmitCompare(Value *Op0, Value *Op1, MVT VT) { // Handle 'null' like i32/i64 0. if (isa<ConstantPointerNull>(Op1)) - Op1 = Constant::getNullValue(TD.getIntPtrType()); + Op1 = Context->getNullValue(TD.getIntPtrType()); // We have two options: compare with register or immediate. If the RHS of // the compare is an immediate that we can fold into this compare, use diff --git a/lib/Target/X86/X86InstrInfo.cpp b/lib/Target/X86/X86InstrInfo.cpp index 572b71dbc0..cb98c057c4 100644 --- a/lib/Target/X86/X86InstrInfo.cpp +++ b/lib/Target/X86/X86InstrInfo.cpp @@ -20,6 +20,7 @@ #include "X86TargetMachine.h" #include "llvm/GlobalVariable.h" #include "llvm/DerivedTypes.h" +#include "llvm/LLVMContext.h" #include "llvm/ADT/STLExtras.h" #include "llvm/CodeGen/MachineConstantPool.h" #include "llvm/CodeGen/MachineFrameInfo.h" @@ -2312,7 +2313,7 @@ MachineInstr* X86InstrInfo::foldMemoryOperandImpl(MachineFunction &MF, MachineConstantPool &MCP = *MF.getConstantPool(); const VectorType *Ty = VectorType::get(Type::Int32Ty, 4); Constant *C = LoadMI->getOpcode() == X86::V_SET0 ? - ConstantVector::getNullValue(Ty) : + MF.getFunction()->getContext()->getNullValue(Ty) : ConstantVector::getAllOnesValue(Ty); unsigned CPI = MCP.getConstantPoolIndex(C, 16); diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 2cf3fd7f2a..39ad04f53e 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -408,9 +408,10 @@ X("instcombine", "Combine redundant instructions"); // getComplexity: Assign a complexity or rank value to LLVM Values... // 0 -> undef, 1 -> Const, 2 -> Other, 3 -> Arg, 3 -> Unary, 4 -> OtherInst -static unsigned getComplexity(Value *V) { +static unsigned getComplexity(LLVMContext *Context, Value *V) { if (isa<Instruction>(V)) { - if (BinaryOperator::isNeg(V) || BinaryOperator::isFNeg(V) || + if (BinaryOperator::isNeg(*Context, V) || + BinaryOperator::isFNeg(*Context, V) || BinaryOperator::isNot(V)) return 3; return 4; @@ -521,7 +522,8 @@ static bool ValueRequiresCast(Instruction::CastOps opcode, const Value *V, // bool InstCombiner::SimplifyCommutative(BinaryOperator &I) { bool Changed = false; - if (getComplexity(I.getOperand(0)) < getComplexity(I.getOperand(1))) + if (getComplexity(Context, I.getOperand(0)) < + getComplexity(Context, I.getOperand(1))) Changed = !I.swapOperands(); if (!I.isAssociative()) return Changed; @@ -559,7 +561,8 @@ bool InstCombiner::SimplifyCommutative(BinaryOperator &I) { /// so that theyare listed from right (least complex) to left (most complex). /// This puts constants before unary operators before binary operators. bool InstCombiner::SimplifyCompare(CmpInst &I) { - if (getComplexity(I.getOperand(0)) >= getComplexity(I.getOperand(1))) + if (getComplexity(Context, I.getOperand(0)) >= + getComplexity(Context, I.getOperand(1))) return false; I.swapOperands(); // Compare instructions are not associative so there's nothing else we can do. @@ -570,7 +573,7 @@ bool InstCombiner::SimplifyCompare(CmpInst &I) { // if the LHS is a constant zero (which is the 'negate' form). // static inline Value *dyn_castNegVal(Value *V, LLVMContext *Context) { - if (BinaryOperator::isNeg(V)) + if (BinaryOperator::isNeg(*Context, V)) return BinaryOperator::getNegArgument(V); // Constants can be considered to be negated values if they can be folded. @@ -589,7 +592,7 @@ static inline Value *dyn_castNegVal(Value *V, LLVMContext *Context) { // form). // static inline Value *dyn_castFNegVal(Value *V, LLVMContext *Context) { - if (BinaryOperator::isFNeg(V)) + if (BinaryOperator::isFNeg(*Context, V)) return BinaryOperator::getFNegArgument(V); // Constants can be considered to be negated values if they can be folded. @@ -2185,7 +2188,7 @@ Instruction *InstCombiner::visitAdd(BinaryOperator &I) { if (Value *RHSV = dyn_castNegVal(RHS, Context)) { Instruction *NewAdd = BinaryOperator::CreateAdd(LHSV, RHSV, "sum"); InsertNewInstBefore(NewAdd, I); - return BinaryOperator::CreateNeg(NewAdd); + return BinaryOperator::CreateNeg(*Context, NewAdd); } } @@ -2530,9 +2533,11 @@ Instruction *InstCombiner::visitSub(BinaryOperator &I) { if (BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1)) { if (Op1I->getOpcode() == Instruction::Add) { if (Op1I->getOperand(0) == Op0) // X-(X+Y) == -Y - return BinaryOperator::CreateNeg(Op1I->getOperand(1), I.getName()); + return BinaryOperator::CreateNeg(*Context, Op1I->getOperand(1), + I.getName()); else if (Op1I->getOperand(1) == Op0) // X-(Y+X) == -Y - return BinaryOperator::CreateNeg(Op1I->getOperand(0), I.getName()); + return BinaryOperator::CreateNeg(*Context, Op1I->getOperand(0), + I.getName()); else if (ConstantInt *CI1 = dyn_cast<ConstantInt>(I.getOperand(0))) { if (ConstantInt *CI2 = dyn_cast<ConstantInt>(Op1I->getOperand(1))) // C1-(X+C2) --> (C1-C2)-X @@ -2593,7 +2598,8 @@ Instruction *InstCombiner::visitSub(BinaryOperator &I) { return ReplaceInstUsesWith(I, Op0I->getOperand(0)); } else if (Op0I->getOpcode() == Instruction::Sub) { if (Op0I->getOperand(0) == Op1) // (X-Y)-X == -Y - return BinaryOperator::CreateNeg(Op0I->getOperand(1), I.getName()); + return BinaryOperator::CreateNeg(*Context, Op0I->getOperand(1), + I.getName()); } } @@ -2619,9 +2625,11 @@ Instruction *InstCombiner::visitFSub(BinaryOperator &I) { if (BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1)) { if (Op1I->getOpcode() == Instruction::FAdd) { if (Op1I->getOperand(0) == Op0) // X-(X+Y) == -Y - return BinaryOperator::CreateFNeg(Op1I->getOperand(1), I.getName()); + return BinaryOperator::CreateFNeg(*Context, Op1I->getOperand(1), + I.getName()); else if (Op1I->getOperand(1) == Op0) // X-(Y+X) == -Y - return BinaryOperator::CreateFNeg(Op1I->getOperand(0), I.getName()); + return BinaryOperator::CreateFNeg(*Context, Op1I->getOperand(0), + I.getName()); } } @@ -2683,7 +2691,7 @@ Instruction *InstCombiner::visitMul(BinaryOperator &I) { if (CI->equalsInt(1)) // X * 1 == X return ReplaceInstUsesWith(I, Op0); if (CI->isAllOnesValue()) // X * -1 == 0 - X - return BinaryOperator::CreateNeg(Op0, I.getName()); + return BinaryOperator::CreateNeg(*Context, Op0, I.getName()); const APInt& Val = cast<ConstantInt>(CI)->getValue(); if (Val.isPowerOf2()) { // Replace X*(2^C) with X << C @@ -2695,7 +2703,7 @@ Instruction *InstCombiner::visitMul(BinaryOperator &I) { if (ConstantVector *Op1V = dyn_cast<ConstantVector>(Op1)) { if (Op1V->isAllOnesValue()) // X * -1 == 0 - X - return BinaryOperator::CreateNeg(Op0, I.getName()); + return BinaryOperator::CreateNeg(*Context, Op0, I.getName()); // As above, vector X*splat(1.0) -> X in all defined cases. if (Constant *Splat = Op1V->getSplatValue()) { @@ -3108,7 +3116,7 @@ Instruction *InstCombiner::visitSDiv(BinaryOperator &I) { if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { // sdiv X, -1 == -X if (RHS->isAllOnesValue()) - return BinaryOperator::CreateNeg(Op0); + return BinaryOperator::CreateNeg(*Context, Op0); } // If the sign bits of both operands are zero (i.e. we can prove they are @@ -4042,7 +4050,7 @@ Instruction *InstCombiner::visitAnd(BinaryOperator &I) { ConstantInt *A = dyn_cast<ConstantInt>(Op0LHS); if (!(A && A->isZero()) && // avoid infinite recursion. MaskedValueIsZero(Op0LHS, Mask)) { - Instruction *NewNeg = BinaryOperator::CreateNeg(Op0RHS); + Instruction *NewNeg = BinaryOperator::CreateNeg(*Context, Op0RHS); InsertNewInstBefore(NewNeg, I); return BinaryOperator::CreateAnd(NewNeg, AndRHS); } @@ -7094,7 +7102,7 @@ Instruction *InstCombiner::visitICmpInstWithInstAndIntCst(ICmpInst &ICI, else if (Value *NegVal = dyn_castNegVal(BOp0, Context)) return new ICmpInst(*Context, ICI.getPredicate(), NegVal, BOp1); else if (BO->hasOneUse()) { - Instruction *Neg = BinaryOperator::CreateNeg(BOp1); + Instruction *Neg = BinaryOperator::CreateNeg(*Context, BOp1); InsertNewInstBefore(Neg, ICI); Neg->takeName(BO); return new ICmpInst(*Context, ICI.getPredicate(), BOp0, Neg); @@ -9587,7 +9595,8 @@ Instruction *InstCombiner::visitSelectInst(SelectInst &SI) { NegVal = Context->getConstantExprNeg(C); } else { NegVal = InsertNewInstBefore( - BinaryOperator::CreateNeg(SubOp->getOperand(1), "tmp"), SI); + BinaryOperator::CreateNeg(*Context, SubOp->getOperand(1), + "tmp"), SI); } Value *NewTrueOp = OtherAddOp; diff --git a/lib/Transforms/Scalar/PredicateSimplifier.cpp b/lib/Transforms/Scalar/PredicateSimplifier.cpp index c82c4ff3bf..24ac7bf30b 100644 --- a/lib/Transforms/Scalar/PredicateSimplifier.cpp +++ b/lib/Transforms/Scalar/PredicateSimplifier.cpp @@ -1341,6 +1341,7 @@ namespace { BasicBlock *TopBB; Instruction *TopInst; bool &modified; + LLVMContext *Context; typedef InequalityGraph::Node Node; @@ -1660,7 +1661,8 @@ namespace { Top(DTDFS->getNodeForBlock(TopBB)), TopBB(TopBB), TopInst(NULL), - modified(modified) + modified(modified), + Context(TopBB->getContext()) { assert(Top && "VRPSolver created for unreachable basic block."); } @@ -1760,7 +1762,7 @@ namespace { } break; case Instruction::Or: { // "or i32 %a, %b" EQ 0 then %a EQ 0 and %b EQ 0 - Constant *Zero = Constant::getNullValue(Ty); + Constant *Zero = Context->getNullValue(Ty); if (Canonical == Zero) { add(Zero, Op0, ICmpInst::ICMP_EQ, NewContext); add(Zero, Op1, ICmpInst::ICMP_EQ, NewContext); @@ -1783,10 +1785,10 @@ namespace { } if (Canonical == LHS) { if (isa<ConstantInt>(Canonical)) - add(RHS, Constant::getNullValue(Ty), ICmpInst::ICMP_EQ, + add(RHS, Context->getNullValue(Ty), ICmpInst::ICMP_EQ, NewContext); } else if (isRelatedBy(LHS, Canonical, ICmpInst::ICMP_NE)) { - add(RHS, Constant::getNullValue(Ty), ICmpInst::ICMP_NE, + add(RHS, Context->getNullValue(Ty), ICmpInst::ICMP_NE, NewContext); } } break; @@ -1831,10 +1833,10 @@ namespace { } // TODO: The GEPI indices are all zero. Copy from definition to operand, // jumping the type plane as needed. - if (isRelatedBy(GEPI, Constant::getNullValue(GEPI->getType()), + if (isRelatedBy(GEPI, Context->getNullValue(GEPI->getType()), ICmpInst::ICMP_NE)) { Value *Ptr = GEPI->getPointerOperand(); - add(Ptr, Constant::getNullValue(Ptr->getType()), ICmpInst::ICMP_NE, + add(Ptr, Context->getNullValue(Ptr->getType()), ICmpInst::ICMP_NE, NewContext); } } else if (CastInst *CI = dyn_cast<CastInst>(I)) { @@ -1888,7 +1890,7 @@ namespace { const Type *Ty = BO->getType(); assert(!Ty->isFPOrFPVector() && "Float in work queue!"); - Constant *Zero = Constant::getNullValue(Ty); + Constant *Zero = Context->getNullValue(Ty); Constant *One = ConstantInt::get(Ty, 1); ConstantInt *AllOnes = ConstantInt::getAllOnesValue(Ty); @@ -2110,9 +2112,9 @@ namespace { // TODO: The GEPI indices are all zero. Copy from operand to definition, // jumping the type plane as needed. Value *Ptr = GEPI->getPointerOperand(); - if (isRelatedBy(Ptr, Constant::getNullValue(Ptr->getType()), + if (isRelatedBy(Ptr, Context->getNullValue(Ptr->getType()), ICmpInst::ICMP_NE)) { - add(GEPI, Constant::getNullValue(GEPI->getType()), ICmpInst::ICMP_NE, + add(GEPI, Context->getNullValue(GEPI->getType()), ICmpInst::ICMP_NE, NewContext); } } @@ -2496,7 +2498,8 @@ namespace { void PredicateSimplifier::Forwards::visitAllocaInst(AllocaInst &AI) { VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, &AI); - VRP.add(Constant::getNullValue(AI.getType()), &AI, ICmpInst::ICMP_NE); + VRP.add(AI.getParent()->getContext()->getNullValue(AI.getType()), + &AI, ICmpInst::ICMP_NE); VRP.solve(); } @@ -2506,7 +2509,8 @@ namespace { if (isa<Constant>(Ptr)) return; VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, &LI); - VRP.add(Constant::getNullValue(Ptr->getType()), Ptr, ICmpInst::ICMP_NE); + VRP.add(LI.getParent()->getContext()->getNullValue(Ptr->getType()), + Ptr, ICmpInst::ICMP_NE); VRP.solve(); } @@ -2515,7 +2519,8 @@ namespace { if (isa<Constant>(Ptr)) return; VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, &SI); - VRP.add(Constant::getNullValue(Ptr->getType()), Ptr, ICmpInst::ICMP_NE); + VRP.add(SI.getParent()->getContext()->getNullValue(Ptr->getType()), + Ptr, ICmpInst::ICMP_NE); VRP.solve(); } @@ -2550,8 +2555,8 @@ namespace { case Instruction::SDiv: { Value *Divisor = BO.getOperand(1); VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, &BO); - VRP.add(Constant::getNullValue(Divisor->getType()), Divisor, - ICmpInst::ICMP_NE); + VRP.add(BO.getParent()->getContext()->getNullValue(Divisor->getType()), + Divisor, ICmpInst::ICMP_NE); VRP.solve(); break; } diff --git a/lib/Transforms/Scalar/Reassociate.cpp b/lib/Transforms/Scalar/Reassociate.cpp index 845c312c22..054e09d3c5 100644 --- a/lib/Transforms/Scalar/Reassociate.cpp +++ b/lib/Transforms/Scalar/Reassociate.cpp @@ -178,7 +178,7 @@ unsigned Reassociate::getRank(Value *V) { // If this is a not or neg instruction, do not count it for rank. This // assures us that X and ~X will have the same rank. if (!I->getType()->isInteger() || - (!BinaryOperator::isNot(I) && !BinaryOperator::isNeg(I))) + (!BinaryOperator::isNot(I) && !BinaryOperator::isNeg(*Context, I))) ++Rank; //DOUT << "Calculated Rank[" << V->getName() << "] = " @@ -264,12 +264,12 @@ void Reassociate::LinearizeExprTree(BinaryOperator *I, // If this is a multiply expression tree and it contains internal negations, // transform them into multiplies by -1 so they can be reassociated. if (I->getOpcode() == Instruction::Mul) { - if (!LHSBO && LHS->hasOneUse() && BinaryOperator::isNeg(LHS)) { + if (!LHSBO && LHS->hasOneUse() && BinaryOperator::isNeg(*Context, LHS)) { LHS = LowerNegateToMultiply(cast<Instruction>(LHS), ValueRankMap, Context); LHSBO = isReassociableOp(LHS, Opcode); } - if (!RHSBO && RHS->hasOneUse() && BinaryOperator::isNeg(RHS)) { + if (!RHSBO && RHS->hasOneUse() && BinaryOperator::isNeg(*Context, RHS)) { RHS = LowerNegateToMultiply(cast<Instruction>(RHS), ValueRankMap, Context); RHSBO = isReassociableOp(RHS, Opcode); @@ -373,7 +373,7 @@ void Reassociate::RewriteExprTree(BinaryOperator *I, // version of the value is returned, and BI is left pointing at the instruction // that should be processed next by the reassociation pass. // -static Value *NegateValue(Value *V, Instruction *BI) { +static Value *NegateValue(LLVMContext *Context, Value *V, Instruction *BI) { // We are trying to expose opportunity for reassociation. One of the things // that we want to do to achieve this is to push a negation as deep into an // expression chain as possible, to expose the add instructions. In practice, @@ -386,8 +386,8 @@ static Value *NegateValue(Value *V, Instruction *BI) { if (Instruction *I = dyn_cast<Instruction>(V)) if (I->getOpcode() == Instruction::Add && I->hasOneUse()) { // Push the negates through the add. - I->setOperand(0, NegateValue(I->getOperand(0), BI)); - I->setOperand(1, NegateValue(I->getOperand(1), BI)); + I->setOperand(0, NegateValue(Context, I->getOperand(0), BI)); + I->setOperand(1, NegateValue(Context, I->getOperand(1), BI)); // We must move the add instruction here, because the neg instructions do // not dominate the old add instruction in general. By moving it, we are @@ -402,14 +402,14 @@ static Value *NegateValue(Value *V, Instruction *BI) { // Insert a 'neg' instruction that subtracts the value from zero to get the // negation. // - return BinaryOperator::CreateNeg(V, V->getName() + ".neg", BI); + return BinaryOperator::CreateNeg(*Context, V, V->getName() + ".neg", BI); } /// ShouldBreakUpSubtract - Return true if we should break up this subtract of /// X-Y into (X + -Y). -static bool ShouldBreakUpSubtract(Instruction *Sub) { +static bool ShouldBreakUpSubtract(LLVMContext *Context, Instruction *Sub) { // If this is a negation, we can't split it up! - if (BinaryOperator::isNeg(Sub)) + if (BinaryOperator::isNeg(*Context, Sub)) return false; // Don't bother to break this up unless either the LHS is an associable add or @@ -431,7 +431,7 @@ static bool ShouldBreakUpSubtract(Instruction *Sub) { /// BreakUpSubtract - If we have (X-Y), and if either X is an add, or if this is /// only used by an add, transform this into (X+(0-Y)) to promote better /// reassociation. -static Instruction *BreakUpSubtract(Instruction *Sub, +static Instruction *BreakUpSubtract(LLVMContext *Context, Instruction *Sub, std::map<AssertingVH<>, unsigned> &ValueRankMap) { // Convert a subtract into an add and a neg instruction... so that sub // instructions can be commuted with other add instructions... @@ -439,7 +439,7 @@ static Instruction *BreakUpSubtract(Instruction *Sub, // Calculate the negative value of Operand 1 of the sub instruction... // and set it as the RHS of the add instruction we just made... // - Value *NegVal = NegateValue(Sub->getOperand(1), Sub); + Value *NegVal = NegateValue(Context, Sub->getOperand(1), Sub); Instruction *New = BinaryOperator::CreateAdd(Sub->getOperand(0), NegVal, "", Sub); New->takeName(Sub); @@ -663,7 +663,7 @@ Value *Reassociate::OptimizeExpression(BinaryOperator *I, for (unsigned i = 0, e = Ops.size(); i != e; ++i) { assert(i < Ops.size()); // Check for X and -X in the operand list. - if (BinaryOperator::isNeg(Ops[i].Op)) { + if (BinaryOperator::isNeg(*Context, Ops[i].Op)) { Value *X = BinaryOperator::getNegArgument(Ops[i].Op); unsigned FoundX = FindInOperandList(Ops, i, X); if (FoundX != i) { @@ -798,10 +798,10 @@ void Reassociate::ReassociateBB(BasicBlock *BB) { // If this is a subtract instruction which is not already in negate form, // see if we can convert it to X+-Y. if (BI->getOpcode() == Instruction::Sub) { - if (ShouldBreakUpSubtract(BI)) { - BI = BreakUpSubtract(BI, ValueRankMap); + if (ShouldBreakUpSubtract(Context, BI)) { + BI = BreakUpSubtract(Context, BI, ValueRankMap); MadeChange = true; - } else if (BinaryOperator::isNeg(BI)) { + } else if (BinaryOperator::isNeg(*Context, BI)) { // Otherwise, this is a negation. See if the operand is a multiply tree // and if this is not an inner node of a multiply tree. if (isReassociableOp(BI->getOperand(1), Instruction::Mul) && diff --git a/lib/Transforms/Utils/LowerInvoke.cpp b/lib/Transforms/Utils/LowerInvoke.cpp index b8e0fd88f0..2e13ed3bd8 100644 --- a/lib/Transforms/Utils/LowerInvoke.cpp +++ b/lib/Transforms/Utils/LowerInvoke.cpp @@ -251,7 +251,7 @@ bool LowerInvoke::insertCheapEHSupport(Function &F) { // Insert a return instruction. This really should be a "barrier", as it // is unreachable. ReturnInst::Create(F.getReturnType() == Type::VoidTy ? 0 : - Constant::getNullValue(F.getReturnType()), UI); + Context->getNullValue(F.getReturnType()), UI); // Remove the unwind instruction now. BB->getInstList().erase(UI); @@ -285,7 +285,7 @@ void LowerInvoke::rewriteExpensiveInvoke(InvokeInst *II, unsigned InvokeNo, BasicBlock::iterator NI = II->getNormalDest()->getFirstNonPHI(); // nonvolatile. - new StoreInst(Constant::getNullValue(Type::Int32Ty), InvokeNum, false, NI); + new StoreInst(Context->getNullValue(Type::Int32Ty), InvokeNum, false, NI); // Add a switch case to our unwind block. CatchSwitch->addCase(InvokeNoC, II->getUnwindDest()); @@ -473,7 +473,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { new AllocaInst(JBLinkTy, 0, Align, "jblink", F.begin()->begin()); std::vector<Value*> Idx; - Idx.push_back(Constant::getNullValue(Type::Int32Ty)); + Idx.push_back(Context->getNullValue(Type::Int32Ty)); Idx.push_back(ConstantInt::get(Type::Int32Ty, 1)); OldJmpBufPtr = GetElementPtrInst::Create(JmpBuf, Idx.begin(), Idx.end(), "OldBuf", EntryBB->getTerminator()); @@ -525,7 +525,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { // Compare the return value to zero. Value *IsNormal = new ICmpInst(EntryBB->getTerminator(), ICmpInst::ICMP_EQ, SJRet, - Constant::getNullValue(SJRet->getType()), + Context->getNullValue(SJRet->getType()), "notunwind"); // Nuke the uncond branch. EntryBB->getTerminator()->eraseFromParent(); @@ -559,14 +559,14 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { // Load the JBList, if it's null, then there was no catch! Value *NotNull = new ICmpInst(*UnwindHandler, ICmpInst::ICMP_NE, BufPtr, - Constant::getNullValue(BufPtr->getType()), + Context->getNullValue(BufPtr->getType()), "notnull"); BranchInst::Create(UnwindBlock, TermBlock, NotNull, UnwindHandler); // Create the block to do the longjmp. // Get a pointer to the jmpbuf and longjmp. std::vector<Value*> Idx; - Idx.push_back(Constant::getNullValue(Type::Int32Ty)); + Idx.push_back(Context->getNullValue(Type::Int32Ty)); Idx.push_back(ConstantInt::get(Type::Int32Ty, 0)); Idx[0] = GetElementPtrInst::Create(BufPtr, Idx.begin(), Idx.end(), "JmpBuf", UnwindBlock); diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index 3919643c00..1f622310df 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -24,6 +24,7 @@ #include "llvm/DerivedTypes.h" #include "llvm/Function.h" #include "llvm/GlobalAlias.h" +#include "llvm/LLVMContext.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" @@ -40,7 +41,7 @@ using namespace llvm; /// BitCastConstantVector - Convert the specified ConstantVector node to the /// specified vector type. At this point, we know that the elements of the /// input vector constant are all simple integer or FP values. -static Constant *BitCastConstantVector(ConstantVector *CV, +static Constant *BitCastConstantVector(LLVMContext &Context, ConstantVector *CV, const VectorType *DstTy) { // If this cast changes element count then we can't handle it here: // doing so requires endianness information. This should be handled by @@ -60,8 +61,9 @@ static Constant *BitCastConstantVector(ConstantVector *CV, std::vector<Constant*> Result; const Type *DstEltTy = DstTy->getElementType(); for (unsigned i = 0; i != NumElts; ++i) - Result.push_back(ConstantExpr::getBitCast(CV->getOperand(i), DstEltTy)); - return ConstantVector::get(Result); + Result.push_back(Context.getConstantExprBitCast(CV->getOperand(i), + DstEltTy)); + return Context.getConstantVector(Result); } /// This function determines which opcode to use to fold two constant cast @@ -89,7 +91,8 @@ foldConstantCastPair( Type::Int64Ty); } -static Constant *FoldBitCast(Constant *V, const Type *DestTy) { +static Constant *FoldBitCast(LLVMContext &Context, + Constant *V, const Type *DestTy) { const Type *SrcTy = V->getType(); if (SrcTy == DestTy) return V; // no-op cast @@ -100,13 +103,13 @@ static Constant *FoldBitCast(Constant *V, const Type *DestTy) { if (const PointerType *DPTy = dyn_cast<PointerType>(DestTy)) if (PTy->getAddressSpace() == DPTy->getAddressSpace()) { SmallVector<Value*, 8> IdxList; - IdxList.push_back(Constant::getNullValue(Type::Int32Ty)); + IdxList.push_back(Context.getNullValue(Type::Int32Ty)); const Type *ElTy = PTy->getElementType(); while (ElTy != DPTy->getElementType()) { if (const StructType *STy = dyn_cast<StructType>(ElTy)) { if (STy->getNumElements() == 0) break; ElTy = STy->getElementType(0); - IdxList.push_back(Constant::getNullValue(Type::Int32Ty)); + IdxList.push_back(Context.getNullValue(Type::Int32Ty)); } else if (const SequentialType *STy = dyn_cast<SequentialType>(ElTy)) { if (isa<PointerType>(ElTy)) break; // Can't index into pointers! @@ -118,7 +121,8 @@ static Constant *FoldBitCast(Constant *V, const Type *DestTy) { } if (ElTy == DPTy->getElementType()) - return ConstantExpr::getGetElementPtr(V, &IdxList[0], IdxList.size()); + return Context.getConstantExprGetElementPtr(V, &IdxList[0], + IdxList.size()); } // Handle casts from one vector constant to another. We know that the src @@ -130,23 +134,24 @@ static Constant *FoldBitCast(Constant *V, const Type *DestTy) { SrcTy = NULL; // First, check for null. Undef is already handled. if (isa<ConstantAggregateZero>(V)) - return Constant::getNullValue(DestTy); + return Context.getNullValue(DestTy); if (ConstantVector *CV = dyn_cast<ConstantVector>(V)) - return BitCastConstantVector(CV, DestPTy); + return BitCastConstantVector(Context, CV, DestPTy); } // Canonicalize scalar-to-vector bitcasts into vector-to-vector bitcasts // This allows for other simplifications (although some of them // can only be handled by Analysis/ConstantFolding.cpp). if (isa<ConstantInt>(V) || isa<ConstantFP>(V)) - return ConstantExpr::getBitCast(ConstantVector::get(&V, 1), DestPTy); + return Context.getConstantExprBitCast( + Context.getConstantVector(&V, 1), DestPTy); } // Finally, implement bitcast folding now. The code below doesn't handle // bitcast right. if (isa<ConstantPointerNull>(V)) // ptr->ptr cast. - return ConstantPointerNull::get(cast<PointerType>(DestTy)); + return Context.getConstantPointerNull(cast<PointerType>(DestTy)); // Handle integral constant input. if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { @@ -156,7 +161,7 @@ static Constant *FoldBitCast(Constant *V, const Type *DestTy) { return V; if (DestTy->isFloatingPoint()) - return ConstantFP::get(APFloat(CI->getValue(), + return Context.getConstantFP(APFloat(CI->getValue(), DestTy != Type::PPC_FP128Ty)); // Otherwise, can't fold this (vector?) @@ -166,13 +171,14 @@ static Constant *FoldBitCast(Constant *V, const Type *DestTy) { // Handle ConstantFP input. if (const ConstantFP *FP = dyn_cast<ConstantFP>(V)) // FP -> Integral. - return ConstantInt::get(FP->getValueAPF().bitcastToAPInt()); + return Context.getConstantInt(FP->getValueAPF().bitcastToAPInt()); return 0; } -Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, +Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, + unsigned opc, const Constant *V, const Type *DestTy) { if (isa<UndefValue>(V)) { // zext(undef) = 0, because the top bits will be zero. @@ -180,8 +186,8 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, // [us]itofp(undef) = 0, because the result value is bounded. if (opc == Instruction::ZExt || opc == Instruction::SExt || opc == Instruction::UIToFP || opc == Instruction::SIToFP) - return Constant::getNullValue(DestTy); - return UndefValue::get(DestTy); + return Context.getNullValue(DestTy); + return Context.getUndef(DestTy); } // No compile-time operations on this type yet. if (V->getType() == Type::PPC_FP128Ty || DestTy == Type::PPC_FP128Ty) @@ -193,7 +199,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, if (CE->isCast()) { // Try hard to fold cast of cast because they are often eliminable. if (unsigned newOpc = foldConstantCastPair(opc, CE, DestTy)) - return ConstantExpr::getCast(newOpc, CE->getOperand(0), DestTy); + return Context.getConstantExprCast(newOpc, CE->getOperand(0), DestTy); } else if (CE->getOpcode() == Instruction::GetElementPtr) { // If all of the indexes in the GEP are null values, there is no pointer // adjustment going on. We might as well cast the source pointer. @@ -205,7 +211,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, } if (isAllNull) // This is casting one pointer type to another, always BitCast - return ConstantExpr::getPointerCast(CE->getOperand(0), DestTy); + return Context.getConstantExprPointerCast(CE->getOperand(0), DestTy); } } @@ -220,9 +226,9 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, const VectorType *DestVecTy = cast<VectorType>(DestTy); const Type *DstEltTy = DestVecTy->getElementType(); for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i) - res.push_back(ConstantExpr::getCast(opc, + res.push_back(Context.getConstantExprCast(opc, CV->getOperand(i), DstEltTy)); - return ConstantVector::get(DestVecTy, res); + return Context.getConstantVector(DestVecTy, res); } // We actually have to do a cast now. Perform the cast according to the @@ -239,7 +245,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, DestTy == Type::FP128Ty ? APFloat::IEEEquad : APFloat::Bogus, APFloat::rmNearestTiesToEven, &ignored); - return ConstantFP::get(Val); + return Context.getConstantFP(Val); } return 0; // Can't fold. case Instruction::FPToUI: @@ -252,16 +258,16 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, (void) V.convertToInteger(x, DestBitWidth, opc==Instruction::FPToSI, APFloat::rmTowardZero, &ignored); APInt Val(DestBitWidth, 2, x); - return ConstantInt::get(Val); + return Context.getConstantInt(Val); } return 0; // Can't fold. case Instruction::IntToPtr: //always treated as unsigned if (V->isNullValue()) // Is it an integral null value? - return ConstantPointerNull::get(cast<PointerType>(DestTy)); + return Context.getConstantPointerNull(cast<PointerType>(DestTy)); return 0; // Other pointer types cannot be casted case Instruction::PtrToInt: // always treated as unsigned if (V->isNullValue()) // is it a null pointer value? - return ConstantInt::get(DestTy, 0); + return Context.getConstantInt(DestTy, 0); return 0; // Other pointer types cannot be casted case Instruction::UIToFP: case Instruction::SIToFP: @@ -273,7 +279,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, (void)apf.convertFromAPInt(api, opc==Instruction::SIToFP, APFloat::rmNearestTiesToEven); - return ConstantFP::get(apf); + return Context.getConstantFP(apf); } return 0; case Instruction::ZExt: @@ -281,7 +287,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth(); APInt Result(CI->getValue()); Result.zext(BitWidth); - return ConstantInt::get(Result); + return Context.getConstantInt(Result); } return 0; case Instruction::SExt: @@ -289,7 +295,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth(); APInt Result(CI->getValue()); Result.sext(BitWidth); - return ConstantInt::get(Result); + return Context.getConstantInt(Result); } return 0; case Instruction::Trunc: @@ -297,11 +303,11 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth(); APInt Result(CI->getValue()); Result.trunc(BitWidth); - return ConstantInt::get(Result); + return Context.getConstantInt(Result); } return 0; case Instruction::BitCast: - return FoldBitCast(const_cast<Constant*>(V), DestTy); + return FoldBitCast(Context, const_cast<Constant*>(V), DestTy); default: assert(!"Invalid CE CastInst opcode"); break; @@ -311,7 +317,8 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, return 0; } -Constant *llvm::ConstantFoldSelectInstruction(const Constant *Cond, +Constant *llvm::ConstantFoldSelectInstruction(LLVMContext&, + const Constant *Cond, const Constant *V1, const Constant *V2) { if (const ConstantInt *CB = dyn_cast<ConstantInt>(Cond)) @@ -324,12 +331,13 @@ Constant *llvm::ConstantFoldSelectInstruction(const Constant *Cond, return 0; } -Constant *llvm::ConstantFoldExtractElementInstruction(const Constant *Val, +Constant *llvm::ConstantFoldExtractElementInstruction(LLVMContext &Context, + const Constant *Val, const Constant *Idx) { if (isa<UndefValue>(Val)) // ee(undef, x) -> undef - return UndefValue::get(cast<VectorType>(Val->getType())->getElementType()); + return Context.getUndef(cast<VectorType>(Val->getType())->getElementType()); if (Val->isNullValue()) // ee(zero, x) -> zero - return Constant::getNullValue( + return Context.getNullValue( cast<VectorType>(Val->getType())->getElementType()); if (const ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) { @@ -343,7 +351,8 @@ Constant *llvm::ConstantFoldExtractElementInstruction(const Constant *Val, return 0; } -Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, +Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context, + const Constant *Val, const Constant *Elt, const Constant *Idx) { const ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx); @@ -362,10 +371,10 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, Ops.reserve(numOps); for (unsigned i = 0; i < numOps; ++i) { const Constant *Op = - (idxVal == i) ? Elt : UndefValue::get(Elt->getType()); + (idxVal == i) ? Elt : Context.getUndef(Elt->getType()); Ops.push_back(const_cast<Constant*>(Op)); } - return ConstantVector::get(Ops); + return Context.getConstantVector(Ops); } if (isa<ConstantAggregateZero>(Val)) { // Insertion of scalar constant into vector aggregate zero @@ -380,10 +389,10 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, Ops.reserve(numOps); for (unsigned i = 0; i < numOps; ++i) { const Constant *Op = - (idxVal == i) ? Elt : Constant::getNullValue(Elt->getType()); + (idxVal == i) ? Elt : Context.getNullValue(Elt->getType()); Ops.push_back(const_cast<Constant*>(Op)); } - return ConstantVector::get(Ops); + return Context.getConstantVector(Ops); } if (const ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) { // Insertion of scalar constant into vector constant @@ -394,7 +403,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, (idxVal == i) ? Elt : cast<Constant>(CVal->getOperand(i)); Ops.push_back(const_cast<Constant*>(Op)); } - return ConstantVector::get(Ops); + return Context.getConstantVector(Ops); } return 0; @@ -402,23 +411,25 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, /// GetVectorElement - If C is a ConstantVector, ConstantAggregateZero or Undef /// return the specified element value. Otherwise return null. -static Constant *GetVectorElement(const Constant *C, unsigned EltNo) { +static Constant *GetVectorElement(LLVMContext &Context, const Constant *C, + unsigned EltNo) { if (const ConstantVector *CV = dyn_cast<ConstantVector>(C)) return CV->getOperand(EltNo); const Type *EltTy = cast<VectorType>(C->getType())->getElementType(); if (isa<ConstantAggregateZero>(C)) - return Constant::getNullValue(EltTy); + return Context.getNullValue(EltTy); if (isa<UndefValue>(C)) - return UndefValue::get(EltTy); + return Context.getUndef(EltTy); return 0; } -Constant *llvm::ConstantFoldShuffleVectorInstruction(const Constant *V1, +Constant *llvm::ConstantFoldShuffleVectorInstruction(LLVMContext &Context, + const Constant *V1, const Constant *V2, const Constant *Mask) { // Undefined shuffle mask -> undefined value. - if (isa<UndefValue>(Mask)) return UndefValue::get(V1->getType()); + if (isa<UndefValue>(Mask)) return Context.getUndef(V1->getType()); unsigned MaskNumElts = cast<VectorType>(Mask->getType())->getNumElements(); unsigned SrcNumElts = cast<VectorType>(V1->getType())->getNumElements(); @@ -427,19 +438,19 @@ Constant *llvm::ConstantFoldShuffleVectorInstruction(const Constant *V1, // Loop over the shuffle mask, evaluating each element. SmallVector<Constant*, 32> Result; for (unsigned i = 0; i != MaskNumElts; ++i) { - Constant *InElt = GetVectorElement(Mask, i); + Constant *InElt = GetVectorElement(Context, Mask, i); if (InElt == 0) return 0; if (isa<UndefValue>(InElt)) - InElt = UndefValue::get(EltTy); + InElt = Context.getUndef(EltTy); else if (ConstantInt *CI = dyn_cast<ConstantInt>(InElt)) { unsigned Elt = CI->getZExtValue(); if (Elt >= SrcNumElts*2) - InElt = UndefValue::get(EltTy); + InElt = Context.getUndef(EltTy); else if (Elt >= SrcNumElts) - InElt = GetVectorElement(V2, Elt - SrcNumElts); + InElt = GetVectorElement(Context, V2, Elt - SrcNumElts); else - InElt = GetVectorElement(V1, Elt); + InElt = GetVectorElement(Context, V1, Elt); if (InElt == 0) return 0; } else { // Unknown value. @@ -448,10 +459,11 @@ Constant *llvm::ConstantFoldShuffleVectorInstruction(const Constant *V1, Result.push_back(InElt); } - return ConstantVector::get(&Result[0], Result.size()); + return Context.getConstantVector(&Result[0], Result.size()); } -Constant *llvm::ConstantFoldExtractValueInstruction(const Constant *Agg, +Constant *llvm::ConstantFoldExtractValueInstruction(LLVMContext &Context, + const Constant *Agg, const unsigned *Idxs, unsigned NumIdx) { // Base case: no indices, so return the entire value. @@ -459,22 +471,23 @@ Constant *llvm::ConstantFoldExtractValueInstruction(const Constant *Agg, return const_cast<Constant *>(Agg); if (isa<UndefValue>(Agg)) // ev(undef, x) -> undef - return UndefValue::get(ExtractValueInst::getIndexedType(Agg->getType(), + return Context.getUndef(ExtractValueInst::getIndexedType(Agg->getType(), Idxs, Idxs + NumIdx)); if (isa<ConstantAggregateZero>(Agg)) // ev(0, x) -> 0 return - Constant::getNullValue(ExtractValueInst::getIndexedType(Agg->getType(), + Context.getNullValue(ExtractValueInst::getIndexedType(Agg->getType(), Idxs, Idxs + NumIdx)); // Otherwise recurse. - return ConstantFoldExtractValueInstruction(Agg->getOperand(*Idxs), + return ConstantFoldExtractValueInstruction(Context, Agg->getOperand(*Idxs), Idxs+1, NumIdx-1); } -Constant *llvm::ConstantFoldInsertValueInstruction(const Constant *Agg, +Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context, + const Constant *Agg, const Constant *Val, const unsigned *Idxs, unsigned NumIdx) { @@ -500,15 +513,15 @@ Constant *llvm::ConstantFoldInsertValueInstruction(const Constant *Agg, const Type *MemberTy = AggTy->getTypeAtIndex(i); const Constant *Op = (*Idxs == i) ? - ConstantFoldInsertValueInstruction(UndefValue::get(MemberTy), + ConstantFoldInsertValueInstruction(Context, Context.getUndef(MemberTy), Val, Idxs+1, NumIdx-1) : - UndefValue::get(MemberTy); + Context.getUndef(MemberTy); Ops[i] = const_cast<Constant*>(Op); } if (isa<StructType>(AggTy)) - return ConstantStruct::get(Ops); + return Context.getConstantStruct(Ops); else - return ConstantArray::get(cast<ArrayType>(AggTy), Ops); + return Context.getConstantArray(cast<ArrayType>(AggTy), Ops); } if (isa<ConstantAggregateZero>(Agg)) { // Insertion of constant into aggregate zero @@ -528,15 +541,16 @@ Constant *llvm::ConstantFoldInsertValueInstruction(const Constant *Agg, const Type *MemberTy = AggTy->getTypeAtIndex(i); const Constant *Op = (*Idxs == i) ? - ConstantFoldInsertValueInstruction(Constant::getNullValue(MemberTy), + ConstantFoldInsertValueInstruction(Context, + Context.getNullValue(MemberTy), Val, Idxs+1, NumIdx-1) : - Constant::getNullValue(MemberTy); + Context.getNullValue(MemberTy); Ops[i] = const_cast<Constant*>(Op); } if (isa<StructType>(AggTy)) - return ConstantStruct::get(Ops); + return Context.getConstantStruct(Ops); else - return ConstantArray::get(cast<ArrayType>(AggTy), Ops); + return Context.getConstantArray(cast<ArrayType>(AggTy), Ops); } if (isa<ConstantStruct>(Agg) || isa<ConstantArray>(Agg)) { // Insertion of constant into aggregate constant @@ -544,16 +558,16 @@ Constant *llvm::ConstantFoldInsertValueInstruction(const Constant *Agg, for (unsigned i = 0; i < Agg->getNumOperands(); ++i) { const Constant *Op = (*Idxs == i) ? - ConstantFoldInsertValueInstruction(Agg->getOperand(i), + ConstantFoldInsertValueInstruction(Context, Agg->getOperand(i), Val, Idxs+1, NumIdx-1) : Agg->getOperand(i); Ops[i] = const_cast<Constant*>(Op); } Constant *C; if (isa<StructType>(Agg->getType())) - C = ConstantStruct::get(Ops); + C = Context.getConstantStruct(Ops); else - C = ConstantArray::get(cast<ArrayType>(Agg->getType()), Ops); + C = Context.getConstantArray(cast<ArrayType>(Agg->getType()), Ops); return C; } @@ -564,22 +578,23 @@ Constant *llvm::ConstantFoldInsertValueInstruction(const Constant *Agg, /// function pointer to each element pair, producing a new ConstantVector /// constant. Either or both of V1 and V2 may be NULL, meaning a /// ConstantAggregateZero operand. -static Constant *EvalVectorOp(const ConstantVector *V1, +static Constant *EvalVectorOp(LLVMContext &Context, const ConstantVector *V1, const ConstantVector *V2, const VectorType *VTy, Constant *(*FP)(Constant*, Constant*)) { std::vector<Constant*> Res; const Type *EltTy = VTy->getElementType(); for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { - const Constant *C1 = V1 ? V1->getOperand(i) : Constant::getNullValue(EltTy); - const Constant *C2 = V2 ? V2->getOperand(i) : Constant::getNullValue(EltTy); + const Constant *C1 = V1 ? V1->getOperand(i) : Context.getNullValue(EltTy); + const Constant *C2 = V2 ? V2->getOperand(i) : Context.getNullValue(EltTy); Res.push_back(FP(const_cast<Constant*>(C1), const_cast<Constant*>(C2))); } - return ConstantVector::get(Res); + return Context.getConstantVector(Res); } -Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, +Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context, + unsigned Opcode, const Constant *C1, const Constant *C2) { // No compile-time operations on this type yet. @@ -593,29 +608,29 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, if (isa<UndefValue>(C1) && isa<UndefValue>(C2)) // Handle undef ^ undef -> 0 special case. This is a common // idiom (misuse). - return Constant::getNullValue(C1->getType()); + return Context.getNullValue(C1->getType()); // Fallthrough case Instruction::Add: case Instruction::Sub: - return UndefValue::get(C1->getType()); + return Context.getUndef(C1->getType()); case Instruction::Mul: case Instruction::And: - return Constant::getNullValue(C1->getType()); + return Context.getNullValue(C1->getType()); case Instruction::UDiv: case Instruction::SDiv: case Instruction::URem: case Instruction::SRem: if (!isa<UndefValue>(C2)) // undef / X -> 0 - return Constant::getNullValue(C1->getType()); + return Context.getNullValue(C1->getType()); return const_cast<Constant*>(C2); // X / undef -> undef case Instruction::Or: // X | undef -> -1 if (const VectorType *PTy = dyn_cast<VectorType>(C1->getType())) - return ConstantVector::getAllOnesValue(PTy); - return ConstantInt::getAllOnesValue(C1->getType()); + return Context.getAllOnesValue(PTy); + return Context.getAllOnesValue(C1->getType()); case Instruction::LShr: if (isa<UndefValue>(C2) && isa<UndefValue>(C1)) return const_cast<Constant*>(C1); // undef lshr undef -> undef - return Constant::getNullValue(C1->getType()); // X lshr undef -> 0 + return Context.getNullValue(C1->getType()); // X lshr undef -> 0 // undef lshr X -> 0 case Instruction::AShr: if (!isa<UndefValue>(C2)) @@ -626,7 +641,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, return const_cast<Constant*>(C1); // X ashr undef --> X case Instruction::Shl: // undef << X -> 0 or X << undef -> 0 - return Constant::getNullValue(C1->getType()); + return Context.getNullValue(C1->getType()); } } @@ -649,14 +664,14 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, if (CI2->equalsInt(1)) return const_cast<Constant*>(C1); // X / 1 == X if (CI2->equalsInt(0)) - return UndefValue::get(CI2->getType()); // X / 0 == undef + return Context.getUndef(CI2->getType()); // X / 0 == undef break; case Instruction::URem: case Instruction::SRem: if (CI2->equalsInt(1)) - return Constant::getNullValue(CI2->getType()); // X % 1 == 0 + return Context.getNullValue(CI2->getType()); // X % 1 == 0 if (CI2->equalsInt(0)) - return UndefValue::get(CI2->getType()); // X % 0 == undef + return Context.getUndef(CI2->getType()); // X % 0 == undef break; case Instruction::And: if (CI2->isZero()) return const_cast<Constant*>(C2); // X & 0 == 0 @@ -691,7 +706,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, // If checking bits we know are clear, return zero. if ((CI2->getValue() & BitsNotSet) == CI2->getValue()) - return Constant::getNullValue(CI2->getType()); + return Context.getNullValue(CI2->getType()); } } } @@ -708,8 +723,8 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, // ashr (zext C to Ty), C2 -> lshr (zext C, CSA), C2 if (const ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) if (CE1->getOpcode() == Instruction::ZExt) // Top bits known zero. - return ConstantExpr::getLShr(const_cast<Constant*>(C1), - const_cast<Constant*>(C2)); + return Context.getConstantExprLShr(const_cast<Constant*>(C1), + const_cast<Constant*>(C2)); break; } } @@ -724,53 +739,53 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, default: break; case Instruction::Add: - return ConstantInt::get(C1V + C2V); + return Context.getConstantInt(C1V + C2V); case Instruction::Sub: - return ConstantInt::get(C1V - C2V); + return Context.getConstantInt(C1V - C2V); case Instruction::Mul: - return ConstantInt::get(C1V * C2V); + return Context.getConstantInt(C1V * C2V); case Instruction::UDiv: assert(!CI2->isNullValue() && "Div by zero handled above"); - return ConstantInt::get(C1V.udiv(C2V)); + return Context.getConstantInt(C1V.udiv(C2V)); case Instruction::SDiv: assert(!CI2->isNullValue() && "Div by zero handled above"); if (C2V.isAllOnesValue() && C1V.isMinSignedValue()) - return UndefValue::get(CI1->getType()); // MIN_INT / -1 -> undef - return ConstantInt::get(C1V.sdiv(C2V)); + return Context.getUndef(CI1->getType()); // MIN_INT / -1 -> undef + return Context.getConstantInt(C1V.sdiv(C2V)); case Instruction::URem: assert(!CI2->isNullValue() && "Div by zero handled above"); - return ConstantInt::get(C1V.urem(C2V)); + return Context.getConstantInt(C1V.urem(C2V)); case Instruction::SRem: assert(!CI2->isNullValue() && "Div by zero handled above"); if (C2V.isAllOnesValue() && C1V.isMinSignedValue()) - return UndefValue::get(CI1->getType()); // MIN_INT % -1 -> undef - return ConstantInt::get(C1V.srem(C2V)); + return Context.getUndef(CI1->getType()); // MIN_INT % -1 -> undef + return Context.getConstantInt(C1V.srem(C2V)); case Instruction::And: - return ConstantInt::get(C1V & C2V); + return Context.getConstantInt(C1V & C2V); case Instruction::Or: - return ConstantInt::get(C1V | C2V); + return Context.getConstantInt(C1V | C2V); case Instruction::Xor: - return ConstantInt::get(C1V ^ C2V); + return Context.getConstantInt(C1V ^ C2V); case Instruction::Shl: { uint32_t shiftAmt = C2V.getZExtValue(); if (shiftAmt < C1V.getBitWidth()) - return ConstantInt::get(C1V.shl(shiftAmt)); + return Context.getConstantInt(C1V.shl(shiftAmt)); else - return UndefValue::get(C1->getType()); // too big shift is undef + return Context.getUndef(C1->getType()); // too big shift is undef } case Instruction::LShr: { uint32_t shiftAmt = C2V.getZExtValue(); if (shiftAmt < C1V.getBitWidth()) - return ConstantInt::get(C1V.lshr(shiftAmt)); + return Context.getConstantInt(C1V.lshr(shiftAmt)); else - return UndefValue::get(C1->getType()); // too big shift is undef + return Context.getUndef(C1->getType()); // too big shift is undef } case Instruction::AShr: { uint32_t shiftAmt = C2V.getZExtValue(); if (shiftAmt < C1V.getBitWidth()) - return ConstantInt::get(C1V.ashr(shiftAmt)); + return Context.getConstantInt(C1V.ashr(shiftAmt)); else - return UndefValue::get(C1->getType()); // too big shift is undef + return Context.getUndef(C1->getType()); // too big shift is undef } } } @@ -798,19 +813,19 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, break; case Instruction::FAdd: (void)C3V.add(C2V, APFloat::rmNearestTiesToEven); - return ConstantFP::get(C3V); + return Context.getConstantFP(C3V); case Instruction::FSub: (void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven); - return ConstantFP::get(C3V); + return Context.getConstantFP(C3V); case Instruction::FMul: (void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven); - return ConstantFP::get(C3V); + return Context.getConstantFP(C3V); case Instruction::FDiv: (void)C3V.divide(C2V, APFloat::rmNearestTiesToEven); - return ConstantFP::get(C3V); + return Context.getConstantFP(C3V); case Instruction::FRem: (void)C3V.mod(C2V, APFloat::rmNearestTiesToEven); - return ConstantFP::get(C3V); + return Context.getConstantFP(C3V); } } } else if (const VectorType *VTy = dyn_cast<VectorType>(C1->getType())) { @@ -822,41 +837,41 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, default: break; case Instruction::Add: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getAdd); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getAdd); case Instruction::FAdd: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFAdd); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFAdd); case Instruction::Sub: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getSub); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getSub); case Instruction::FSub: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFSub); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFSub); case Instruction::Mul: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getMul); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getMul); case Instruction::FMul: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFMul); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFMul); case Instruction::UDiv: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getUDiv); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getUDiv); case Instruction::SDiv: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getSDiv); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getSDiv); case Instruction::FDiv: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFDiv); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFDiv); case Instruction::URem: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getURem); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getURem); case Instruction::SRem: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getSRem); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getSRem); case Instruction::FRem: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFRem); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFRem); case Instruction::And: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getAnd); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getAnd); case Instruction::Or: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getOr); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getOr); case Instruction::Xor: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getXor); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getXor); case Instruction::LShr: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getLShr); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getLShr); case Instruction::AShr: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getAShr); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getAShr); case Instruction::Shl: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getShl); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getShl); } } } @@ -877,7 +892,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, case Instruction::Or: case Instruction::Xor: // No change of opcode required. - return ConstantFoldBinaryInstruction(Opcode, C2, C1); + return ConstantFoldBinaryInstruction(Context, Opcode, C2, C1); case Instruction::Shl: case Instruction::LShr: @@ -923,7 +938,8 @@ static bool isMaybeZeroSizedType(const Type *Ty) { /// first is less than the second, return -1, if the second is less than the /// first, return 1. If the constants are not integral, return -2. /// -static int IdxCompare(Constant *C1, Constant *C2, const Type *ElTy) { +static int IdxCompare(LLVMContext &Context, Constant *C1, Constant *C2, + const Type *ElTy) { if (C1 == C2) return 0; // Ok, we found a different index. If they are not ConstantInt, we can't do @@ -934,10 +950,10 @@ static int IdxCompare(Constant *C1, Constant *C2, const Type *ElTy) { // Ok, we have two differing integer indices. Sign extend them to be the same // type. Long is always big enough, so we use it. if (C1->getType() != Type::Int64Ty) - C1 = ConstantExpr::getSExt(C1, Type::Int64Ty); + C1 = Context.getConstantExprSExt(C1, Type::Int64Ty); if (C2->getType() != Type::Int64Ty) - C2 = ConstantExpr::getSExt(C2, Type::Int64Ty); + C2 = Context.getConstantExprSExt(C2, Type::Int64Ty); if (C1 == C2) return 0; // They are equal @@ -966,7 +982,8 @@ static int IdxCompare(Constant *C1, Constant *C2, const Type *ElTy) { /// To simplify this code we canonicalize the relation so that the first /// operand is always the most "complex" of the two. We consider ConstantFP /// to be the simplest, and ConstantExprs to be the most complex. -static FCmpInst::Predicate evaluateFCmpRelation(const Constant *V1, +static FCmpInst::Predicate evaluateFCmpRelation(LLVMContext &Context, + const Constant *V1, const Constant *V2) { assert(V1->getType() == V2->getType() && "Cannot compare values of different types!"); @@ -985,15 +1002,15 @@ static FCmpInst::Predicate evaluateFCmpRelation(const Constant *V1, Constant *C1 = const_cast<Constant*>(V1); Constant *C2 = const_cast<Constant*>(V2); R = dyn_cast<ConstantInt>( - ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, C1, C2)); + Context.getConstantExprFCmp(FCmpInst::FCMP_OEQ, C1, C2)); if (R && !R->isZero()) return FCmpInst::FCMP_OEQ; R = dyn_cast<ConstantInt>( - ConstantExpr::getFCmp(FCmpInst::FCMP_OLT, C1, C2)); + Context.getConstantExprFCmp(FCmpInst::FCMP_OLT, C1, C2)); if (R && !R->isZero()) return FCmpInst::FCMP_OLT; R = dyn_cast<ConstantInt>( - ConstantExpr::getFCmp(FCmpInst::FCMP_OGT, C1, C2)); + Context.getConstantExprFCmp(FCmpInst::FCMP_OGT, C1, C2)); if (R && !R->isZero()) return FCmpInst::FCMP_OGT; @@ -1002,7 +1019,7 @@ static FCmpInst::Predicate evaluateFCmpRelation(const Constant *V1, } // If the first operand is simple and second is ConstantExpr, swap operands. - FCmpInst::Predicate SwappedRelation = evaluateFCmpRelation(V2, V1); + FCmpInst::Predicate SwappedRelation = evaluateFCmpRelation(Context, V2, V1); if (SwappedRelation != FCmpInst::BAD_FCMP_PREDICATE) return FCmpInst::getSwappedPredicate(SwappedRelation); } else { @@ -1037,7 +1054,8 @@ static FCmpInst::Predicate evaluateFCmpRelation(const Constant *V1, /// constants (like ConstantInt) to be the simplest, followed by /// GlobalValues, followed by ConstantExpr's (the most complex). /// -static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, +static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context, + const Constant *V1, const Constant *V2, bool isSigned) { assert(V1->getType() == V2->getType() && @@ -1052,15 +1070,15 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, Constant *C1 = const_cast<Constant*>(V1); Constant *C2 = const_cast<Constant*>(V2); ICmpInst::Predicate pred = ICmpInst::ICMP_EQ; - R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2)); + R = dyn_cast<ConstantInt>(Context.getConstantExprICmp(pred, C1, C2)); if (R && !R->isZero()) return pred; pred = isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT; - R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2)); + R = dyn_cast<ConstantInt>(Context.getConstantExprICmp(pred, C1, C2)); if (R && !R->isZero()) return pred; pred = isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT; - R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2)); + R = dyn_cast<ConstantInt>(Context.getConstantExprICmp(pred, C1, C2)); if (R && !R->isZero()) return pred; @@ -1070,14 +1088,14 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, // If the first operand is simple, swap operands. ICmpInst::Predicate SwappedRelation = - evaluateICmpRelation(V2, V1, isSigned); + evaluateICmpRelation(Context, V2, V1, isSigned); if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE) return ICmpInst::getSwappedPredicate(SwappedRelation); } else if (const GlobalValue *CPR1 = dyn_cast<GlobalValue>(V1)) { if (isa<ConstantExpr>(V2)) { // Swap as necessary. ICmpInst::Predicate SwappedRelation = - evaluateICmpRelation(V2, V1, isSigned); + evaluateICmpRelation(Context, V2, V1, isSigned); if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE) return ICmpInst::getSwappedPredicate(SwappedRelation); else @@ -1123,8 +1141,8 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, bool sgnd = isSigned; if (CE1->getOpcode() == Instruction::ZExt) isSigned = false; if (CE1->getOpcode() == Instruction::SExt) isSigned = true; - return evaluateICmpRelation(CE1Op0, - Constant::getNullValue(CE1Op0->getType()), + return evaluateICmpRelation(Context, CE1Op0, + Context.getNullValue(CE1Op0->getType()), sgnd); } @@ -1139,8 +1157,8 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, bool sgnd = isSigned; if (CE1->getOpcode() == Instruction::ZExt) isSigned = false; if (CE1->getOpcode() == Instruction::SExt) isSigned = true; - return evaluateICmpRelation(CE1->getOperand(0), CE2->getOperand(0), - sgnd); + return evaluateICmpRelation(Context, CE1->getOperand(0), + CE2->getOperand(0), sgnd); } break; @@ -1219,8 +1237,8 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, gep_type_iterator GTI = gep_type_begin(CE1); for (;i != CE1->getNumOperands() && i != CE2->getNumOperands(); ++i, ++GTI) - switch (IdxCompare(CE1->getOperand(i), CE2->getOperand(i), - GTI.getIndexedType())) { + switch (IdxCompare(Context, CE1->getOperand(i), + CE2->getOperand(i), GTI.getIndexedType())) { case -1: return isSigned ? ICmpInst::ICMP_SLT:ICmpInst::ICMP_ULT; case 1: return isSigned ? ICmpInst::ICMP_SGT:ICmpInst::ICMP_UGT; case -2: return ICmpInst::BAD_ICMP_PREDICATE; @@ -1255,25 +1273,26 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, return ICmpInst::BAD_ICMP_PREDICATE; } -Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, +Constant *llvm::ConstantFoldCompareInstruction(LLVMContext &Context, + unsigned short pred, const Constant *C1, const Constant *C2) { const Type *ResultTy; if (const VectorType *VT = dyn_cast<VectorType>(C1->getType())) - ResultTy = VectorType::get(Type::Int1Ty, VT->getNumElements()); + ResultTy = Context.getVectorType(Type::Int1Ty, VT->getNumElements()); else ResultTy = Type::Int1Ty; // Fold FCMP_FALSE/FCMP_TRUE unconditionally. if (pred == FCmpInst::FCMP_FALSE) - return Constant::getNullValue(ResultTy); + return Context.getNullValue(ResultTy); if (pred == FCmpInst::FCMP_TRUE) - return Constant::getAllOnesValue(ResultTy); + return Context.getAllOnesValue(ResultTy); // Handle some degenerate cases first if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) - return UndefValue::get(ResultTy); + return Context.getUndef(ResultTy); // No compile-time operations on this type yet. if (C1->getType() == Type::PPC_FP128Ty) @@ -1285,9 +1304,9 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, // Don't try to evaluate aliases. External weak GV can be null. if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) { if (pred == ICmpInst::ICMP_EQ) - return ConstantInt::getFalse(); + return Context.getConstantIntFalse(); else if (pred == ICmpInst::ICMP_NE) - return ConstantInt::getTrue(); + return Context.getConstantIntTrue(); } // icmp eq/ne(GV,null) -> false/true } else if (C2->isNullValue()) { @@ -1295,9 +1314,9 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, // Don't try to evaluate aliases. External weak GV can be null. if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) { if (pred == ICmpInst::ICMP_EQ) - return ConstantInt::getFalse(); + return Context.getConstantIntFalse(); else if (pred == ICmpInst::ICMP_NE) - return ConstantInt::getTrue(); + return Context.getConstantIntTrue(); } } @@ -1306,16 +1325,26 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, APInt V2 = cast<ConstantInt>(C2)->getValue(); switch (pred) { default: LLVM_UNREACHABLE("Invalid ICmp Predicate"); return 0; - case ICmpInst::ICMP_EQ: return ConstantInt::get(Type::Int1Ty, V1 == V2); - case ICmpInst::ICMP_NE: return ConstantInt::get(Type::Int1Ty, V1 != V2); - case ICmpInst::ICMP_SLT:return ConstantInt::get(Type::Int1Ty, V1.slt(V2)); - case ICmpInst::ICMP_SGT:return ConstantInt::get(Type::Int1Ty, V1.sgt(V2)); - case ICmpInst::ICMP_SLE:return ConstantInt::get(Type::Int1Ty, V1.sle(V2)); - case ICmpInst::ICMP_SGE:return ConstantInt::get(Type::Int1Ty, V1.sge(V2)); - case ICmpInst::ICMP_ULT:return ConstantInt::get(Type::Int1Ty, V1.ult(V2)); - case ICmpInst::ICMP_UGT:return ConstantInt::get(Type::Int1Ty, V1.ugt(V2)); - case ICmpInst::ICMP_ULE:return ConstantInt::get(Type::Int1Ty, V1.ule(V2)); - case ICmpInst::ICMP_UGE:return ConstantInt::get(Type::Int1Ty, V1.uge(V2)); + case ICmpInst::ICMP_EQ: + return Context.getConstantInt(Type::Int1Ty, V1 == V2); + case ICmpInst::ICMP_NE: + return Context.getConstantInt(Type::Int1Ty, V1 != V2); + case ICmpInst::ICMP_SLT: + return Context.getConstantInt(Type::Int1Ty, V1.slt(V2)); + case ICmpInst::ICMP_SGT: + return Context.getConstantInt(Type::Int1Ty, V1.sgt(V2)); + case ICmpInst::ICMP_SLE: + return Context.getConstantInt(Type::Int1Ty, V1.sle(V2)); + case ICmpInst::ICMP_SGE: + return Context.getConstantInt(Type::Int1Ty, V1.sge(V2)); + case ICmpInst::ICMP_ULT: + return Context.getConstantInt(Type::Int1Ty, V1.ult(V2)); + case ICmpInst::ICMP_UGT: + return Context.getConstantInt(Type::Int1Ty, V1.ugt(V2)); + case ICmpInst::ICMP_ULE: + return Context.getConstantInt(Type::Int1Ty, V1.ule(V2)); + case ICmpInst::ICMP_UGE: + return Context.getConstantInt(Type::Int1Ty, V1.uge(V2)); } } else if (isa<ConstantFP>(C1) && isa<ConstantFP>(C2)) { APFloat C1V = cast<ConstantFP>(C1)->getValueAPF(); @@ -1323,61 +1352,62 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, APFloat::cmpResult R = C1V.compare(C2V); switch (pred) { default: LLVM_UNREACHABLE("Invalid FCmp Predicate"); return 0; - case FCmpInst::FCMP_FALSE: return ConstantInt::getFalse(); - case FCmpInst::FCMP_TRUE: return ConstantInt::getTrue(); + case FCmpInst::FCMP_FALSE: return Context.getConstantIntFalse(); + case FCmpInst::FCMP_TRUE: return Context.getConstantIntTrue(); case FCmpInst::FCMP_UNO: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered); + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered); case FCmpInst::FCMP_ORD: - return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpUnordered); + return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpUnordered); case FCmpInst::FCMP_UEQ: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered || + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered || R==APFloat::cmpEqual); case FCmpInst::FCMP_OEQ: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpEqual); + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpEqual); case FCmpInst::FCMP_UNE: - return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpEqual); + return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpEqual); case FCmpInst::FCMP_ONE: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan || + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpLessThan || R==APFloat::cmpGreaterThan); case FCmpInst::FCMP_ULT: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered || + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered || R==APFloat::cmpLessThan); case FCmpInst::FCMP_OLT: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan); + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpLessThan); case FCmpInst::FCMP_UGT: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered || + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered || R==APFloat::cmpGreaterThan); case FCmpInst::FCMP_OGT: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan); + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpGreaterThan); case FCmpInst::FCMP_ULE: - return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpGreaterThan); + return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpGreaterThan); case FCmpInst::FCMP_OLE: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan || + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpLessThan || R==APFloat::cmpEqual); case FCmpInst::FCMP_UGE: - return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpLessThan); + return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpLessThan); case FCmpInst::FCMP_OGE: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan || + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpGreaterThan || R==APFloat::cmpEqual); } } else if (isa<VectorType>(C1->getType())) { SmallVector<Constant*, 16> C1Elts, C2Elts; - C1->getVectorElements(C1Elts); - C2->getVectorElements(C2Elts); + C1->getVectorElements(Context, C1Elts); + C2->getVectorElements(Context, C2Elts); // If we can constant fold the comparison of each element, constant fold // the whole vector comparison. SmallVector<Constant*, 4> ResElts; for (unsigned i = 0, e = C1Elts.size(); i != e; ++i) { // Compare the elements, producing an i1 result or constant expr. - ResElts.push_back(ConstantExpr::getCompare(pred, C1Elts[i], C2Elts[i])); + ResElts.push_back( + Context.getConstantExprCompare(pred, C1Elts[i], C2Elts[i])); } - return ConstantVector::get(&ResElts[0], ResElts.size()); + return Context.getConstantVector(&ResElts[0], ResElts.size()); } if (C1->getType()->isFloatingPoint()) { int Result = -1; // -1 = unknown, 0 = known false, 1 = known true. - switch (evaluateFCmpRelation(C1, C2)) { + switch (evaluateFCmpRelation(Context, C1, C2)) { default: LLVM_UNREACHABLE("Unknown relation!"); case FCmpInst::FCMP_UNO: case FCmpInst::FCMP_ORD: @@ -1431,12 +1461,12 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, // If we evaluated the result, return it now. if (Result != -1) - return ConstantInt::get(Type::Int1Ty, Result); + return Context.getConstantInt(Type::Int1Ty, Result); } else { // Evaluate the relation between the two constants, per the predicate. int Result = -1; // -1 = unknown, 0 = known false, 1 = known true. - switch (evaluateICmpRelation(C1, C2, CmpInst::isSigned(pred))) { + switch (evaluateICmpRelation(Context, C1, C2, CmpInst::isSigned(pred))) { default: LLVM_UNREACHABLE("Unknown relational!"); case ICmpInst::BAD_ICMP_PREDICATE: break; // Couldn't determine anything about these constants. @@ -1508,7 +1538,7 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, // If we evaluated the result, return it now. if (Result != -1) - return ConstantInt::get(Type::Int1Ty, Result); + return Context.getConstantInt(Type::Int1Ty, Result); if (!isa<ConstantExpr>(C1) && isa<ConstantExpr>(C2)) { // If C2 is a constant expr and C1 isn't, flip them around and fold the @@ -1517,7 +1547,7 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_NE: // No change of predicate required. - return ConstantFoldCompareInstruction(pred, C2, C1); + return ConstantFoldCompareInstruction(Context, pred, C2, C1); case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_SLT: @@ -1529,7 +1559,7 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, case ICmpInst::ICMP_SGE: // Change the predicate as necessary to swap the operands. pred = ICmpInst::getSwappedPredicate((ICmpInst::Predicate)pred); - return ConstantFoldCompareInstruction(pred, C2, C1); + return ConstantFoldCompareInstruction(Context, pred, C2, C1); default: // These predicates cannot be flopped around. break; @@ -1539,7 +1569,8 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, return 0; } -Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, +Constant *llvm::ConstantFoldGetElementPtr(LLVMContext &Context, + const Constant *C, Constant* const *Idxs, unsigned NumIdx) { if (NumIdx == 0 || @@ -1552,7 +1583,7 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, (Value **)Idxs, (Value **)Idxs+NumIdx); assert(Ty != 0 && "Invalid indices for GEP!"); - return UndefValue::get(PointerType::get(Ty, Ptr->getAddressSpace())); + return Context.getUndef(Context.getPointerType(Ty, Ptr->getAddressSpace())); } Constant *Idx0 = Idxs[0]; @@ -1569,8 +1600,8 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, (Value**)Idxs, (Value**)Idxs+NumIdx); assert(Ty != 0 && "Invalid indices for GEP!"); - return - ConstantPointerNull::get(PointerType::get(Ty,Ptr->getAddressSpace())); + return Context.getConstantPointerNull( + Context.getPointerType(Ty,Ptr->getAddressSpace())); } } @@ -1598,19 +1629,21 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, if (!Idx0->isNullValue()) { const Type *IdxTy = Combined->getType(); if (IdxTy != Idx0->getType()) { - Constant *C1 = ConstantExpr::getSExtOrBitCast(Idx0, Type::Int64Ty); - Constant *C2 = ConstantExpr::getSExtOrBitCast(Combined, + Constant *C1 = + Context.getConstantExprSExtOrBitCast(Idx0, Type::Int64Ty); + Constant *C2 = Context.getConstantExprSExtOrBitCast(Combined, Type::Int64Ty); - Combined = ConstantExpr::get(Instruction::Add, C1, C2); + Combined = Context.getConstantExpr(Instruction::Add, C1, C2); } else { Combined = - ConstantExpr::get(Instruction::Add, Idx0, Combined); + Context.getConstantExpr(Instruction::Add, Idx0, Combined); } } NewIndices.push_back(Combined); NewIndices.insert(NewIndices.end(), Idxs+1, Idxs+NumIdx); - return ConstantExpr::getGetElementPtr(CE->getOperand(0), &NewIndices[0], + return Context.getConstantExprGetElementPtr(CE->getOperand(0), + &NewIndices[0], NewIndices.size()); } } @@ -1627,7 +1660,7 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, if (const ArrayType *CAT = dyn_cast<ArrayType>(cast<PointerType>(C->getType())->getElementType())) if (CAT->getElementType() == SAT->getElementType()) - return ConstantExpr::getGetElementPtr( + return Context.getConstantExprGetElementPtr( (Constant*)CE->getOperand(0), Idxs, NumIdx); } @@ -1643,13 +1676,13 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, // Convert the smaller integer to the larger type. if (Offset->getType()->getPrimitiveSizeInBits() < Base->getType()->getPrimitiveSizeInBits()) - Offset = ConstantExpr::getSExt(Offset, Base->getType()); + Offset = Context.getConstantExprSExt(Offset, Base->getType()); else if (Base->getType()->getPrimitiveSizeInBits() < Offset->getType()->getPrimitiveSizeInBits()) - Base = ConstantExpr::getZExt(Base, Offset->getType()); + Base = Context.getConstantExprZExt(Base, Offset->getType()); - Base = ConstantExpr::getAdd(Base, Offset); - return ConstantExpr::getIntToPtr(Base, CE->getType()); + Base = Context.getConstantExprAdd(Base, Offset); + return Context.getConstantExprIntToPtr(Base, CE->getType()); } } return 0; diff --git a/lib/VMCore/ConstantFold.h b/lib/VMCore/ConstantFold.h index 49aea11870..afa9978767 100644 --- a/lib/VMCore/ConstantFold.h +++ b/lib/VMCore/ConstantFold.h @@ -23,37 +23,47 @@ namespace llvm { class Value; class Constant; class Type; + class LLVMContext; // Constant fold various types of instruction... Constant *ConstantFoldCastInstruction( + LLVMContext &Context, unsigned opcode, ///< The opcode of the cast const Constant *V, ///< The source constant const Type *DestTy ///< The destination type ); - Constant *ConstantFoldSelectInstruction(const Constant *Cond, + Constant *ConstantFoldSelectInstruction(LLVMContext &Context, + const Constant *Cond, const Constant *V1, const Constant *V2); - Constant *ConstantFoldExtractElementInstruction(const Constant *Val, + Constant *ConstantFoldExtractElementInstruction(LLVMContext &Context, + const Constant *Val, const Constant *Idx); - Constant *ConstantFoldInsertElementInstruction(const Constant *Val, + Constant *ConstantFoldInsertElementInstruction(LLVMContext &Context, + const Constant *Val, const Constant *Elt, const Constant *Idx); - Constant *ConstantFoldShuffleVectorInstruction(const Constant *V1, + Constant *ConstantFoldShuffleVectorInstruction(LLVMContext &Context, + const Constant *V1, const Constant *V2, const Constant *Mask); - Constant *ConstantFoldExtractValueInstruction(const Constant *Agg, + Constant *ConstantFoldExtractValueInstruction(LLVMContext &Context, + const Constant *Agg, const unsigned *Idxs, unsigned NumIdx); - Constant *ConstantFoldInsertValueInstruction(const Constant *Agg, + Constant *ConstantFoldInsertValueInstruction(LLVMContext &Context, + const Constant *Agg, const Constant *Val, const unsigned* Idxs, unsigned NumIdx); - Constant *ConstantFoldBinaryInstruction(unsigned Opcode, const Constant *V1, + Constant *ConstantFoldBinaryInstruction(LLVMContext &Context, + unsigned Opcode, const Constant *V1, const Constant *V2); - Constant *ConstantFoldCompareInstruction(unsigned short predicate, + Constant *ConstantFoldCompareInstruction(LLVMContext &Context, + unsigned short predicate, const Constant *C1, const Constant *C2); - Constant *ConstantFoldGetElementPtr(const Constant *C, + Constant *ConstantFoldGetElementPtr(LLVMContext &Context, const Constant *C, Constant* const *Idxs, unsigned NumIdx); } // End llvm namespace diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index 38b30c281e..f8ae2bd79f 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -128,35 +128,6 @@ bool Constant::ContainsRelocations(unsigned Kind) const { return false; } -// Static constructor to create a '0' constant of arbitrary type... -static const uint64_t zero[2] = {0, 0}; -Constant *Constant::getNullValue(const Type *Ty) { - switch (Ty->getTypeID()) { - case Type::IntegerTyID: - return ConstantInt::get(Ty, 0); - case Type::FloatTyID: - return ConstantFP::get(APFloat(APInt(32, 0))); - case Type::DoubleTyID: - return ConstantFP::get(APFloat(APInt(64, 0))); - case Type::X86_FP80TyID: - return ConstantFP::get(APFloat(APInt(80, 2, zero))); - case Type::FP128TyID: - return ConstantFP::get(APFloat(APInt(128, 2, zero), true)); - case Type::PPC_FP128TyID: - return ConstantFP::get(APFloat(APInt(128, 2, zero))); - case Type::PointerTyID: - return ConstantPointerNull::get(cast<PointerType>(Ty)); - case Type::StructTyID: - case Type::ArrayTyID: - case Type::VectorTyID: - return ConstantAggregateZero::get(Ty); - default: - // Function, Label, or Opaque type? - assert(!"Cannot create a null constant of that type!"); - return 0; - } -} - Constant *Constant::getAllOnesValue(const Type *Ty) { if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty)) return ConstantInt::get(APInt::getAllOnesValue(ITy->getBitWidth())); @@ -186,7 +157,8 @@ ConstantVector *ConstantVector::getAllOnesValue(const VectorType *Ty) { /// type, returns the elements of the vector in the specified smallvector. /// This handles breaking down a vector undef into undef elements, etc. For /// constant exprs and other cases we can't handle, we return an empty vector. -void Constant::getVectorElements(SmallVectorImpl<Constant*> &Elts) const { +void Constant::getVectorElements(LLVMContext &Context, + SmallVectorImpl<Constant*> &Elts) const { assert(isa<VectorType>(getType()) && "Not a vector constant!"); if (const ConstantVector *CV = dyn_cast<ConstantVector>(this)) { @@ -198,12 +170,12 @@ void Constant::getVectorElements(SmallVectorImpl<Constant*> &Elts) const { const VectorType *VT = cast<VectorType>(getType()); if (isa<ConstantAggregateZero>(this)) { Elts.assign(VT->getNumElements(), - Constant::getNullValue(VT->getElementType())); + Context.getNullValue(VT->getElementType())); return; } if (isa<UndefValue>(this)) { - Elts.assign(VT->getNumElements(), UndefValue::get(VT->getElementType())); + Elts.assign(VT->getNumElements(), Context.getUndef(VT->getElementType())); return; } @@ -361,12 +333,6 @@ bool ConstantFP::isNullValue() const { return Val.isZero() && !Val.isNegative(); } -ConstantFP *ConstantFP::getNegativeZero(const Type *Ty) { - APFloat apf = cast <ConstantFP>(Constant::getNullValue(Ty))->getValueAPF(); - apf.changeSign(); - return ConstantFP::get(apf); -} - bool ConstantFP::isExactlyValue(const APFloat& V) const { return Val.bitwiseIsEqual(V); } @@ -831,26 +797,6 @@ const SmallVector<unsigned, 4> &ConstantExpr::getIndices() const { return cast<InsertValueConstantExpr>(this)->Indices; } -/// ConstantExpr::get* - Return some common constants without having to -/// specify the full Instruction::OPCODE identifier. -/// -Constant *ConstantExpr::getNeg(Constant *C) { - // API compatibility: Adjust integer opcodes to floating-point opcodes. - if (C->getType()->isFPOrFPVector()) - return getFNeg(C); - assert(C->getType()->isIntOrIntVector() && - "Cannot NEG a nonintegral value!"); - return get(Instruction::Sub, - ConstantExpr::getZeroValueForNegationExpr(C->getType()), - C); -} -Constant *ConstantExpr::getFNeg(Constant *C) { - assert(C->getType()->isFPOrFPVector() && - "Cannot FNEG a non-floating-point value!"); - return get(Instruction::FSub, - ConstantExpr::getZeroValueForNegationExpr(C->getType()), - C); -} Constant *ConstantExpr::getNot(Constant *C) { assert(C->getType()->isIntOrIntVector() && "Cannot NOT a nonintegral value!"); @@ -1501,11 +1447,11 @@ bool ConstantArray::isString() const { /// isCString - This method returns true if the array is a string (see /// isString) and it ends in a null byte \\0 and does not contains any other /// null bytes except its terminator. -bool ConstantArray::isCString() const { +bool ConstantArray::isCString(LLVMContext &Context) const { // Check the element type for i8... if (getType()->getElementType() != Type::Int8Ty) return false; - Constant *Zero = Constant::getNullValue(getOperand(0)->getType()); + Constant *Zero = Context.getNullValue(getOperand(0)->getType()); // Last element must be a null. if (getOperand(getNumOperands()-1) != Zero) return false; @@ -2011,7 +1957,8 @@ static inline Constant *getFoldedCast( Instruction::CastOps opc, Constant *C, const Type *Ty) { assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!"); // Fold a few common cases - if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty)) + if (Constant *FC = + ConstantFoldCastInstruction(getGlobalContext(), opc, C, Ty)) return FC; // Look up the constant in the table first to ensure uniqueness @@ -2245,25 +2192,6 @@ Constant *ConstantExpr::getBitCast(Constant *C, const Type *DstTy) { return getFoldedCast(Instruction::BitCast, C, DstTy); } -Constant *ConstantExpr::getAlignOf(const Type *Ty) { - // alignof is implemented as: (i64) gep ({i8,Ty}*)null, 0, 1 - const Type *AligningTy = StructType::get(Type::Int8Ty, Ty, NULL); - Constant *NullPtr = getNullValue(AligningTy->getPointerTo()); - Constant *Zero = ConstantInt::get(Type::Int32Ty, 0); - Constant *One = ConstantInt::get(Type::Int32Ty, 1); - Constant *Indices[2] = { Zero, One }; - Constant *GEP = getGetElementPtr(NullPtr, Indices, 2); - return getCast(Instruction::PtrToInt, GEP, Type::Int32Ty); -} - -Constant *ConstantExpr::getSizeOf(const Type *Ty) { - // sizeof is implemented as: (i64) gep (Ty*)null, 1 - Constant *GEPIdx = ConstantInt::get(Type::Int32Ty, 1); - Constant *GEP = - getGetElementPtr(getNullValue(PointerType::getUnqual(Ty)), &GEPIdx, 1); - return getCast(Instruction::PtrToInt, GEP, Type::Int64Ty); -} - Constant *ConstantExpr::getTy(const Type *ReqTy, unsigned Opcode, Constant *C1, Constant *C2) { // Check the operands for consistency first @@ -2274,7 +2202,8 @@ Constant *ConstantExpr::getTy(const Type *ReqTy, unsigned Opcode, "Operand types in binary constant expression should match"); if (ReqTy == C1->getType() || ReqTy == Type::Int1Ty) - if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2)) + if (Constant *FC = ConstantFoldBinaryInstruction( + getGlobalContext(), Opcode, C1, C2)) return FC; // Fold a few common cases... std::vector<Constant*> argVec(1, C1); argVec.push_back(C2); @@ -2383,7 +2312,8 @@ Constant *ConstantExpr::getSelectTy(const Type *ReqTy, Constant *C, assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands"); if (ReqTy == V1->getType()) - if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2)) + if (Constant *SC = ConstantFoldSelectInstruction( + getGlobalContext(), C, V1, V2)) return SC; // Fold common cases std::vector<Constant*> argVec(3, C); @@ -2403,7 +2333,8 @@ Constant *ConstantExpr::getGetElementPtrTy(const Type *ReqTy, Constant *C, cast<PointerType>(ReqTy)->getElementType() && "GEP indices invalid!"); - if (Constant *FC = ConstantFoldGetElementPtr(C, (Constant**)Idxs, NumIdx)) + if (Constant *FC = ConstantFoldGetElementPtr( + getGlobalContext(), C, (Constant**)Idxs, NumIdx)) return FC; // Fold a few common cases... assert(isa<PointerType>(C->getType()) && @@ -2442,7 +2373,8 @@ ConstantExpr::getICmp(unsigned short pred, Constant* LHS, Constant* RHS) { assert(pred >= ICmpInst::FIRST_ICMP_PREDICATE && pred <= ICmpInst::LAST_ICMP_PREDICATE && "Invalid ICmp Predicate"); - if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS)) + if (Constant *FC = ConstantFoldCompareInstruction( + getGlobalContext(),pred, LHS, RHS)) return FC; // Fold a few common cases... // Look up the constant in the table first to ensure uniqueness @@ -2461,7 +2393,8 @@ ConstantExpr::getFCmp(unsigned short pred, Constant* LHS, Constant* RHS) { assert(LHS->getType() == RHS->getType()); assert(pred <= FCmpInst::LAST_FCMP_PREDICATE && "Invalid FCmp Predicate"); - if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS)) + if (Constant *FC = ConstantFoldCompareInstruction( + getGlobalContext(), pred, LHS, RHS)) return FC; // Fold a few common cases... // Look up the constant in the table first to ensure uniqueness @@ -2477,7 +2410,8 @@ ConstantExpr::getFCmp(unsigned short pred, Constant* LHS, Constant* RHS) { Constant *ConstantExpr::getExtractElementTy(const Type *ReqTy, Constant *Val, Constant *Idx) { - if (Constant *FC = ConstantFoldExtractElementInstruction(Val, Idx)) + if (Constant *FC = ConstantFoldExtractElementInstruction( + getGlobalContext(), Val, Idx)) return FC; // Fold a few common cases... // Look up the constant in the table first to ensure uniqueness std::vector<Constant*> ArgVec(1, Val); @@ -2499,7 +2433,8 @@ Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx) { Constant *ConstantExpr::getInsertElementTy(const Type *ReqTy, Constant *Val, Constant *Elt, Constant *Idx) { - if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx)) + if (Constant *FC = ConstantFoldInsertElementInstruction( + getGlobalContext(), Val, Elt, Idx)) return FC; // Fold a few common cases... // Look up the constant in the table first to ensure uniqueness std::vector<Constant*> ArgVec(1, Val); @@ -2524,7 +2459,8 @@ Constant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt, Constant *ConstantExpr::getShuffleVectorTy(const Type *ReqTy, Constant *V1, Constant *V2, Constant *Mask) { - if (Constant *FC = ConstantFoldShuffleVectorInstruction(V1, V2, Mask)) + if (Constant *FC = ConstantFoldShuffleVectorInstruction( + getGlobalContext(), V1, V2, Mask)) return FC; // Fold a few common cases... // Look up the constant in the table first to ensure uniqueness std::vector<Constant*> ArgVec(1, V1); @@ -2557,7 +2493,8 @@ Constant *ConstantExpr::getInsertValueTy(const Type *ReqTy, Constant *Agg, "insertvalue type invalid!"); assert(Agg->getType()->isFirstClassType() && "Non-first-class type for constant InsertValue expression"); - Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs, NumIdx); + Constant *FC = ConstantFoldInsertValueInstruction( + getGlobalContext(), Agg, Val, Idxs, NumIdx); assert(FC && "InsertValue constant expr couldn't be folded!"); return FC; } @@ -2583,7 +2520,8 @@ Constant *ConstantExpr::getExtractValueTy(const Type *ReqTy, Constant *Agg, "extractvalue indices invalid!"); assert(Agg->getType()->isFirstClassType() && "Non-first-class type for constant extractvalue expression"); - Constant *FC = ConstantFoldExtractValueInstruction(Agg, Idxs, NumIdx); + Constant *FC = ConstantFoldExtractValueInstruction( + getGlobalContext(), Agg, Idxs, NumIdx); assert(FC && "ExtractValue constant expr couldn't be folded!"); return FC; } @@ -2599,20 +2537,6 @@ Constant *ConstantExpr::getExtractValue(Constant *Agg, return getExtractValueTy(ReqTy, Agg, IdxList, NumIdx); } -Constant *ConstantExpr::getZeroValueForNegationExpr(const Type *Ty) { - if (const VectorType *PTy = dyn_cast<VectorType>(Ty)) - if (PTy->getElementType()->isFloatingPoint()) { - std::vector<Constant*> zeros(PTy->getNumElements(), - ConstantFP::getNegativeZero(PTy->getElementType())); - return ConstantVector::get(PTy, zeros); - } - - if (Ty->isFloatingPoint()) - return ConstantFP::getNegativeZero(Ty); - - return Constant::getNullValue(Ty); -} - // destroyConstant - Remove the constant from the constant table... // void ConstantExpr::destroyConstant() { diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index 475d8cdd56..74bcc10041 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -1633,33 +1633,37 @@ BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2, return Res; } -BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const std::string &Name, +BinaryOperator *BinaryOperator::CreateNeg(LLVMContext &Context, + Value *Op, const std::string &Name, Instruction *InsertBefore) { - Value *zero = ConstantExpr::getZeroValueForNegationExpr(Op->getType()); + Value *zero = Context.getZeroValueForNegation(Op->getType()); return new BinaryOperator(Instruction::Sub, zero, Op, Op->getType(), Name, InsertBefore); } -BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const std::string &Name, +BinaryOperator *BinaryOperator::CreateNeg(LLVMContext &Context, + Value *Op, const std::string &Name, BasicBlock *InsertAtEnd) { - Value *zero = ConstantExpr::getZeroValueForNegationExpr(Op->getType()); + Value *zero = Context.getZeroValueForNegation(Op->getType()); return new BinaryOperator(Instruction::Sub, zero, Op, Op->getType(), Name, InsertAtEnd); } -BinaryOperator *BinaryOperator::CreateFNeg(Value *Op, const std::string &Name, +BinaryOperator *BinaryOperator::CreateFNeg(LLVMContext &Context, + Value *Op, const std::string &Name, Instruction *InsertBefore) { - Value *zero = ConstantExpr::getZeroValueForNegationExpr(Op->getType()); + Value *zero = Context.getZeroValueForNegation(Op->getType()); return new BinaryOperator(Instruction::FSub, zero, Op, Op->getType(), Name, InsertBefore); } -BinaryOperator *BinaryOperator::CreateFNeg(Value *Op, const std::string &Name, +BinaryOperator *BinaryOperator::CreateFNeg(LLVMContext &Context, + Value *Op, const std::string &Name, BasicBlock *InsertAtEnd) { - Value *zero = ConstantExpr::getZeroValueForNegationExpr(Op->getType()); + Value *zero = Context.getZeroValueForNegation(Op->getType()); return new BinaryOperator(Instruction::FSub, zero, Op, Op->getType(), Name, InsertAtEnd); @@ -1705,19 +1709,19 @@ static inline bool isConstantAllOnes(const Value *V) { return false; } -bool BinaryOperator::isNeg(const Value *V) { +bool BinaryOperator::isNeg(LLVMContext &Context, const Value *V) { if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(V)) if (Bop->getOpcode() == Instruction::Sub) return Bop->getOperand(0) == - ConstantExpr::getZeroValueForNegationExpr(Bop->getType()); + Context.getZeroValueForNegation(Bop->getType()); return false; } -bool BinaryOperator::isFNeg(const Value *V) { +bool BinaryOperator::isFNeg(LLVMContext &Context, const Value *V) { if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(V)) if (Bop->getOpcode() == Instruction::FSub) return Bop->getOperand(0) == - ConstantExpr::getZeroValueForNegationExpr(Bop->getType()); + Context.getZeroValueForNegation(Bop->getType()); return false; } @@ -1730,7 +1734,6 @@ bool BinaryOperator::isNot(const Value *V) { } Value *BinaryOperator::getNegArgument(Value *BinOp) { - assert(isNeg(BinOp) && "getNegArgument from non-'neg' instruction!"); return cast<BinaryOperator>(BinOp)->getOperand(1); } @@ -1739,7 +1742,6 @@ const Value *BinaryOperator::getNegArgument(const Value *BinOp) { } Value *BinaryOperator::getFNegArgument(Value *BinOp) { - assert(isFNeg(BinOp) && "getFNegArgument from non-'fneg' instruction!"); return cast<BinaryOperator>(BinOp)->getOperand(1); } diff --git a/lib/VMCore/LLVMContext.cpp b/lib/VMCore/LLVMContext.cpp index 4a9953a4f1..e091f2899b 100644 --- a/lib/VMCore/LLVMContext.cpp +++ b/lib/VMCore/LLVMContext.cpp @@ -15,6 +15,7 @@ #include "llvm/LLVMContext.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" +#include "llvm/Instruction.h" #include "llvm/MDNode.h" #include "llvm/Support/ManagedStatic.h" #include "LLVMContextImpl.h" @@ -31,8 +32,34 @@ LLVMContext::LLVMContext() : pImpl(new LLVMContextImpl()) { } LLVMContext::~LLVMContext() { delete pImpl; } // Constant accessors + +// Constructor to create a '0' constant of arbitrary type... +static const uint64_t zero[2] = {0, 0}; Constant* LLVMContext::getNullValue(const Type* Ty) { - return Constant::getNullValue(Ty); + switch (Ty->getTypeID()) { + case Type::IntegerTyID: + return getConstantInt(Ty, 0); + case Type::FloatTyID: + return getConstantFP(APFloat(APInt(32, 0))); + case Type::DoubleTyID: + return getConstantFP(APFloat(APInt(64, 0))); + case Type::X86_FP80TyID: + return getConstantFP(APFloat(APInt(80, 2, zero))); + case Type::FP128TyID: + return getConstantFP(APFloat(APInt(128, 2, zero), true)); + case Type::PPC_FP128TyID: + return getConstantFP(APFloat(APInt(128, 2, zero))); + case Type::PointerTyID: + return getConstantPointerNull(cast<PointerType>(Ty)); + case Type::StructTyID: + case Type::ArrayTyID: + case Type::VectorTyID: + return getConstantAggregateZero(Ty); + default: + // Function, Label, or Opaque type? + assert(!"Cannot create a null constant of that type!"); + return 0; + } } Constant* LLVMContext::getAllOnesValue(const Type* Ty) { @@ -222,7 +249,14 @@ Constant* LLVMContext::getConstantExprSelect(Constant* C, Constant* V1, } Constant* LLVMContext::getConstantExprAlignOf(const Type* Ty) { - return ConstantExpr::getAlignOf(Ty); + // alignof is implemented as: (i64) gep ({i8,Ty}*)null, 0, 1 + const Type *AligningTy = getStructType(Type::Int8Ty, Ty, NULL); + Constant *NullPtr = getNullValue(AligningTy->getPointerTo()); + Constant *Zero = getConstantInt(Type::Int32Ty, 0); + Constant *One = getConstantInt(Type::Int32Ty, 1); + Constant *Indices[2] = { Zero, One }; + Constant *GEP = getConstantExprGetElementPtr(NullPtr, Indices, 2); + return getConstantExprCast(Instruction::PtrToInt, GEP, Type::Int32Ty); } Constant* LLVMContext::getConstantExprCompare(unsigned short pred, @@ -231,11 +265,22 @@ Constant* LLVMContext::getConstantExprCompare(unsigned short pred, } Constant* LLVMContext::getConstantExprNeg(Constant* C) { - return ConstantExpr::getNeg(C); + // API compatibility: Adjust integer opcodes to floating-point opcodes. + if (C->getType()->isFPOrFPVector()) + return getConstantExprFNeg(C); + assert(C->getType()->isIntOrIntVector() && + "Cannot NEG a nonintegral value!"); + return getConstantExpr(Instruction::Sub, + getZeroValueForNegation(C->getType()), + C); } Constant* LLVMContext::getConstantExprFNeg(Constant* C) { - return ConstantExpr::getFNeg(C); + assert(C->getType()->isFPOrFPVector() && + "Cannot FNEG a non-floating-point value!"); + return getConstantExpr(Instruction::FSub, + getZeroValueForNegation(C->getType()), + C); } Constant* LLVMContext::getConstantExprNot(Constant* C) { @@ -365,11 +410,25 @@ Constant* LLVMContext::getConstantExprInsertValue(Constant* Agg, Constant* Val, } Constant* LLVMContext::getConstantExprSizeOf(const Type* Ty) { - return ConstantExpr::getSizeOf(Ty); + // sizeof is implemented as: (i64) gep (Ty*)null, 1 + Constant *GEPIdx = getConstantInt(Type::Int32Ty, 1); + Constant *GEP = getConstantExprGetElementPtr( + getNullValue(getPointerTypeUnqual(Ty)), &GEPIdx, 1); + return getConstantExprCast(Instruction::PtrToInt, GEP, Type::Int64Ty); } Constant* LLVMContext::getZeroValueForNegation(const Type* Ty) { - return ConstantExpr::getZeroValueForNegationExpr(Ty); + if (const VectorType *PTy = dyn_cast<VectorType>(Ty)) + if (PTy->getElementType()->isFloatingPoint()) { + std::vector<Constant*> zeros(PTy->getNumElements(), + getConstantFPNegativeZero(PTy->getElementType())); + return getConstantVector(PTy, zeros); + } + + if (Ty->isFloatingPoint()) + return getConstantFPNegativeZero(Ty); + + return getNullValue(Ty); } @@ -383,7 +442,9 @@ Constant* LLVMContext::getConstantFP(const Type* Ty, double V) { } ConstantFP* LLVMContext::getConstantFPNegativeZero(const Type* Ty) { - return ConstantFP::getNegativeZero(Ty); + APFloat apf = cast <ConstantFP>(getNullValue(Ty))->getValueAPF(); + apf.changeSign(); + return getConstantFP(apf); } @@ -452,6 +513,17 @@ StructType* LLVMContext::getStructType(const std::vector<const Type*>& Params, return StructType::get(Params, isPacked); } +StructType *LLVMContext::getStructType(const Type *type, ...) { + va_list ap; + std::vector<const llvm::Type*> StructFields; + va_start(ap, type); + while (type) { + StructFields.push_back(type); + type = va_arg(ap, llvm::Type*); + } + return StructType::get(StructFields); +} + // ArrayType accessors ArrayType* LLVMContext::getArrayType(const Type* ElementType, uint64_t NumElements) { |