From 33c06adcf10d3ef7bbfc70f09f4966eec2e6c85e Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Sun, 20 Sep 2009 01:35:59 +0000 Subject: [PATCH] Value* were never meant to be const. Removing constness from the constant folder removes a lot of const_casting and requires no changes to clang or llvm-gcc. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@82349 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/VMCore/ConstantFold.cpp | 293 ++++++++++++++++-------------------- lib/VMCore/ConstantFold.h | 40 +++-- 2 files changed, 150 insertions(+), 183 deletions(-) diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index f2b8ad5d92c..3cd4a9f78b8 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -73,7 +73,7 @@ static Constant *BitCastConstantVector(LLVMContext &Context, ConstantVector *CV, static unsigned foldConstantCastPair( unsigned opc, ///< opcode of the second cast constant expression - const ConstantExpr*Op, ///< the first cast constant expression + ConstantExpr *Op, ///< the first cast constant expression const Type *DstTy ///< desintation type of the first cast ) { assert(Op && Op->isCast() && "Can't fold cast of cast without a cast!"); @@ -156,7 +156,7 @@ static Constant *FoldBitCast(LLVMContext &Context, return ConstantPointerNull::get(cast(DestTy)); // Handle integral constant input. - if (const ConstantInt *CI = dyn_cast(V)) { + if (ConstantInt *CI = dyn_cast(V)) { if (DestTy->isInteger()) // Integral -> Integral. This is a no-op because the bit widths must // be the same. Consequently, we just fold to V. @@ -171,7 +171,7 @@ static Constant *FoldBitCast(LLVMContext &Context, } // Handle ConstantFP input. - if (const ConstantFP *FP = dyn_cast(V)) + if (ConstantFP *FP = dyn_cast(V)) // FP -> Integral. return ConstantInt::get(Context, FP->getValueAPF().bitcastToAPInt()); @@ -180,7 +180,7 @@ static Constant *FoldBitCast(LLVMContext &Context, Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, - unsigned opc, const Constant *V, + unsigned opc, Constant *V, const Type *DestTy) { if (isa(V)) { // zext(undef) = 0, because the top bits will be zero. @@ -197,7 +197,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, // If the cast operand is a constant expression, there's a few things we can // do to try to simplify it. - if (const ConstantExpr *CE = dyn_cast(V)) { + if (ConstantExpr *CE = dyn_cast(V)) { if (CE->isCast()) { // Try hard to fold cast of cast because they are often eliminable. if (unsigned newOpc = foldConstantCastPair(opc, CE, DestTy)) @@ -220,7 +220,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, // If the cast operand is a constant vector, perform the cast by // operating on each element. In the cast of bitcasts, the element // count may be mismatched; don't attempt to handle that here. - if (const ConstantVector *CV = dyn_cast(V)) + if (ConstantVector *CV = dyn_cast(V)) if (isa(DestTy) && cast(DestTy)->getNumElements() == CV->getType()->getNumElements()) { @@ -238,7 +238,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, switch (opc) { case Instruction::FPTrunc: case Instruction::FPExt: - if (const ConstantFP *FPC = dyn_cast(V)) { + if (ConstantFP *FPC = dyn_cast(V)) { bool ignored; APFloat Val = FPC->getValueAPF(); Val.convert(DestTy == Type::getFloatTy(Context) ? APFloat::IEEEsingle : @@ -252,7 +252,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, return 0; // Can't fold. case Instruction::FPToUI: case Instruction::FPToSI: - if (const ConstantFP *FPC = dyn_cast(V)) { + if (ConstantFP *FPC = dyn_cast(V)) { const APFloat &V = FPC->getValueAPF(); bool ignored; uint64_t x[2]; @@ -273,7 +273,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, return 0; // Other pointer types cannot be casted case Instruction::UIToFP: case Instruction::SIToFP: - if (const ConstantInt *CI = dyn_cast(V)) { + if (ConstantInt *CI = dyn_cast(V)) { APInt api = CI->getValue(); const uint64_t zero[] = {0, 0}; APFloat apf = APFloat(APInt(DestTy->getPrimitiveSizeInBits(), @@ -285,7 +285,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, } return 0; case Instruction::ZExt: - if (const ConstantInt *CI = dyn_cast(V)) { + if (ConstantInt *CI = dyn_cast(V)) { uint32_t BitWidth = cast(DestTy)->getBitWidth(); APInt Result(CI->getValue()); Result.zext(BitWidth); @@ -293,7 +293,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, } return 0; case Instruction::SExt: - if (const ConstantInt *CI = dyn_cast(V)) { + if (ConstantInt *CI = dyn_cast(V)) { uint32_t BitWidth = cast(DestTy)->getBitWidth(); APInt Result(CI->getValue()); Result.sext(BitWidth); @@ -301,7 +301,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, } return 0; case Instruction::Trunc: - if (const ConstantInt *CI = dyn_cast(V)) { + if (ConstantInt *CI = dyn_cast(V)) { uint32_t BitWidth = cast(DestTy)->getBitWidth(); APInt Result(CI->getValue()); Result.trunc(BitWidth); @@ -309,7 +309,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, } return 0; case Instruction::BitCast: - return FoldBitCast(Context, const_cast(V), DestTy); + return FoldBitCast(Context, V, DestTy); default: assert(!"Invalid CE CastInst opcode"); break; @@ -320,30 +320,29 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, } Constant *llvm::ConstantFoldSelectInstruction(LLVMContext&, - const Constant *Cond, - const Constant *V1, - const Constant *V2) { - if (const ConstantInt *CB = dyn_cast(Cond)) - return const_cast(CB->getZExtValue() ? V1 : V2); + Constant *Cond, + Constant *V1, Constant *V2) { + if (ConstantInt *CB = dyn_cast(Cond)) + return CB->getZExtValue() ? V1 : V2; - if (isa(V1)) return const_cast(V2); - if (isa(V2)) return const_cast(V1); - if (isa(Cond)) return const_cast(V1); - if (V1 == V2) return const_cast(V1); + if (isa(V1)) return V2; + if (isa(V2)) return V1; + if (isa(Cond)) return V1; + if (V1 == V2) return V1; return 0; } Constant *llvm::ConstantFoldExtractElementInstruction(LLVMContext &Context, - const Constant *Val, - const Constant *Idx) { + Constant *Val, + Constant *Idx) { if (isa(Val)) // ee(undef, x) -> undef return UndefValue::get(cast(Val->getType())->getElementType()); if (Val->isNullValue()) // ee(zero, x) -> zero return Constant::getNullValue( cast(Val->getType())->getElementType()); - if (const ConstantVector *CVal = dyn_cast(Val)) { - if (const ConstantInt *CIdx = dyn_cast(Idx)) { + if (ConstantVector *CVal = dyn_cast(Val)) { + if (ConstantInt *CIdx = dyn_cast(Idx)) { return CVal->getOperand(CIdx->getZExtValue()); } else if (isa(Idx)) { // ee({w,x,y,z}, undef) -> w (an arbitrary value). @@ -354,17 +353,17 @@ Constant *llvm::ConstantFoldExtractElementInstruction(LLVMContext &Context, } Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context, - const Constant *Val, - const Constant *Elt, - const Constant *Idx) { - const ConstantInt *CIdx = dyn_cast(Idx); + Constant *Val, + Constant *Elt, + Constant *Idx) { + ConstantInt *CIdx = dyn_cast(Idx); if (!CIdx) return 0; APInt idxVal = CIdx->getValue(); if (isa(Val)) { // Insertion of scalar constant into vector undef // Optimize away insertion of undef if (isa(Elt)) - return const_cast(Val); + return Val; // Otherwise break the aggregate undef into multiple undefs and do // the insertion unsigned numOps = @@ -372,9 +371,9 @@ Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context, std::vector Ops; Ops.reserve(numOps); for (unsigned i = 0; i < numOps; ++i) { - const Constant *Op = + Constant *Op = (idxVal == i) ? Elt : UndefValue::get(Elt->getType()); - Ops.push_back(const_cast(Op)); + Ops.push_back(Op); } return ConstantVector::get(Ops); } @@ -382,7 +381,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context, // Insertion of scalar constant into vector aggregate zero // Optimize away insertion of zero if (Elt->isNullValue()) - return const_cast(Val); + return Val; // Otherwise break the aggregate zero into multiple zeros and do // the insertion unsigned numOps = @@ -390,20 +389,20 @@ Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context, std::vector Ops; Ops.reserve(numOps); for (unsigned i = 0; i < numOps; ++i) { - const Constant *Op = + Constant *Op = (idxVal == i) ? Elt : Constant::getNullValue(Elt->getType()); - Ops.push_back(const_cast(Op)); + Ops.push_back(Op); } return ConstantVector::get(Ops); } - if (const ConstantVector *CVal = dyn_cast(Val)) { + if (ConstantVector *CVal = dyn_cast(Val)) { // Insertion of scalar constant into vector constant std::vector Ops; Ops.reserve(CVal->getNumOperands()); for (unsigned i = 0; i < CVal->getNumOperands(); ++i) { - const Constant *Op = + Constant *Op = (idxVal == i) ? Elt : cast(CVal->getOperand(i)); - Ops.push_back(const_cast(Op)); + Ops.push_back(Op); } return ConstantVector::get(Ops); } @@ -413,9 +412,9 @@ Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context, /// GetVectorElement - If C is a ConstantVector, ConstantAggregateZero or Undef /// return the specified element value. Otherwise return null. -static Constant *GetVectorElement(LLVMContext &Context, const Constant *C, +static Constant *GetVectorElement(LLVMContext &Context, Constant *C, unsigned EltNo) { - if (const ConstantVector *CV = dyn_cast(C)) + if (ConstantVector *CV = dyn_cast(C)) return CV->getOperand(EltNo); const Type *EltTy = cast(C->getType())->getElementType(); @@ -427,9 +426,9 @@ static Constant *GetVectorElement(LLVMContext &Context, const Constant *C, } Constant *llvm::ConstantFoldShuffleVectorInstruction(LLVMContext &Context, - const Constant *V1, - const Constant *V2, - const Constant *Mask) { + Constant *V1, + Constant *V2, + Constant *Mask) { // Undefined shuffle mask -> undefined value. if (isa(Mask)) return UndefValue::get(V1->getType()); @@ -465,12 +464,12 @@ Constant *llvm::ConstantFoldShuffleVectorInstruction(LLVMContext &Context, } Constant *llvm::ConstantFoldExtractValueInstruction(LLVMContext &Context, - const Constant *Agg, + Constant *Agg, const unsigned *Idxs, unsigned NumIdx) { // Base case: no indices, so return the entire value. if (NumIdx == 0) - return const_cast(Agg); + return Agg; if (isa(Agg)) // ev(undef, x) -> undef return UndefValue::get(ExtractValueInst::getIndexedType(Agg->getType(), @@ -489,19 +488,19 @@ Constant *llvm::ConstantFoldExtractValueInstruction(LLVMContext &Context, } Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context, - const Constant *Agg, - const Constant *Val, + Constant *Agg, + Constant *Val, const unsigned *Idxs, unsigned NumIdx) { // Base case: no indices, so replace the entire value. if (NumIdx == 0) - return const_cast(Val); + return Val; if (isa(Agg)) { // Insertion of constant into aggregate undef // Optimize away insertion of undef. if (isa(Val)) - return const_cast(Agg); + return Agg; // Otherwise break the aggregate undef into multiple undefs and do // the insertion. @@ -515,12 +514,12 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context, std::vector Ops(numOps); for (unsigned i = 0; i < numOps; ++i) { const Type *MemberTy = AggTy->getTypeAtIndex(i); - const Constant *Op = + Constant *Op = (*Idxs == i) ? ConstantFoldInsertValueInstruction(Context, UndefValue::get(MemberTy), Val, Idxs+1, NumIdx-1) : UndefValue::get(MemberTy); - Ops[i] = const_cast(Op); + Ops[i] = Op; } if (const StructType* ST = dyn_cast(AggTy)) @@ -532,7 +531,7 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context, // Insertion of constant into aggregate zero // Optimize away insertion of zero. if (Val->isNullValue()) - return const_cast(Agg); + return Agg; // Otherwise break the aggregate zero into multiple zeros and do // the insertion. @@ -546,13 +545,13 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context, std::vector Ops(numOps); for (unsigned i = 0; i < numOps; ++i) { const Type *MemberTy = AggTy->getTypeAtIndex(i); - const Constant *Op = + Constant *Op = (*Idxs == i) ? ConstantFoldInsertValueInstruction(Context, Constant::getNullValue(MemberTy), Val, Idxs+1, NumIdx-1) : Constant::getNullValue(MemberTy); - Ops[i] = const_cast(Op); + Ops[i] = Op; } if (const StructType* ST = dyn_cast(AggTy)) @@ -564,12 +563,12 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context, // Insertion of constant into aggregate constant. std::vector Ops(Agg->getNumOperands()); for (unsigned i = 0; i < Agg->getNumOperands(); ++i) { - const Constant *Op = + Constant *Op = (*Idxs == i) ? ConstantFoldInsertValueInstruction(Context, Agg->getOperand(i), Val, Idxs+1, NumIdx-1) : Agg->getOperand(i); - Ops[i] = const_cast(Op); + Ops[i] = Op; } if (const StructType* ST = dyn_cast(Agg->getType())) @@ -583,8 +582,7 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context, Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context, unsigned Opcode, - const Constant *C1, - const Constant *C2) { + Constant *C1, Constant *C2) { // No compile-time operations on this type yet. if (C1->getType() == Type::getPPC_FP128Ty(Context)) return 0; @@ -610,23 +608,23 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context, case Instruction::SRem: if (!isa(C2)) // undef / X -> 0 return Constant::getNullValue(C1->getType()); - return const_cast(C2); // X / undef -> undef + return C2; // X / undef -> undef case Instruction::Or: // X | undef -> -1 if (const VectorType *PTy = dyn_cast(C1->getType())) return Constant::getAllOnesValue(PTy); return Constant::getAllOnesValue(C1->getType()); case Instruction::LShr: if (isa(C2) && isa(C1)) - return const_cast(C1); // undef lshr undef -> undef + return C1; // undef lshr undef -> undef return Constant::getNullValue(C1->getType()); // X lshr undef -> 0 // undef lshr X -> 0 case Instruction::AShr: if (!isa(C2)) - return const_cast(C1); // undef ashr X --> undef + return C1; // undef ashr X --> undef else if (isa(C1)) - return const_cast(C1); // undef ashr undef -> undef + return C1; // undef ashr undef -> undef else - return const_cast(C1); // X ashr undef --> X + return C1; // X ashr undef --> X case Instruction::Shl: // undef << X -> 0 or X << undef -> 0 return Constant::getNullValue(C1->getType()); @@ -634,23 +632,23 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context, } // Handle simplifications when the RHS is a constant int. - if (const ConstantInt *CI2 = dyn_cast(C2)) { + if (ConstantInt *CI2 = dyn_cast(C2)) { switch (Opcode) { case Instruction::Add: - if (CI2->equalsInt(0)) return const_cast(C1); // X + 0 == X + if (CI2->equalsInt(0)) return C1; // X + 0 == X break; case Instruction::Sub: - if (CI2->equalsInt(0)) return const_cast(C1); // X - 0 == X + if (CI2->equalsInt(0)) return C1; // X - 0 == X break; case Instruction::Mul: - if (CI2->equalsInt(0)) return const_cast(C2); // X * 0 == 0 + if (CI2->equalsInt(0)) return C2; // X * 0 == 0 if (CI2->equalsInt(1)) - return const_cast(C1); // X * 1 == X + return C1; // X * 1 == X break; case Instruction::UDiv: case Instruction::SDiv: if (CI2->equalsInt(1)) - return const_cast(C1); // X / 1 == X + return C1; // X / 1 == X if (CI2->equalsInt(0)) return UndefValue::get(CI2->getType()); // X / 0 == undef break; @@ -662,11 +660,11 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context, return UndefValue::get(CI2->getType()); // X % 0 == undef break; case Instruction::And: - if (CI2->isZero()) return const_cast(C2); // X & 0 == 0 + if (CI2->isZero()) return C2; // X & 0 == 0 if (CI2->isAllOnesValue()) - return const_cast(C1); // X & -1 == X + return C1; // X & -1 == X - if (const ConstantExpr *CE1 = dyn_cast(C1)) { + if (ConstantExpr *CE1 = dyn_cast(C1)) { // (zext i32 to i64) & 4294967295 -> (zext i32 to i64) if (CE1->getOpcode() == Instruction::ZExt) { unsigned DstWidth = CI2->getType()->getBitWidth(); @@ -674,7 +672,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context, CE1->getOperand(0)->getType()->getPrimitiveSizeInBits(); APInt PossiblySetBits(APInt::getLowBitsSet(DstWidth, SrcWidth)); if ((PossiblySetBits & CI2->getValue()) == PossiblySetBits) - return const_cast(C1); + return C1; } // If and'ing the address of a global with a constant, fold it. @@ -700,26 +698,25 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context, } break; case Instruction::Or: - if (CI2->equalsInt(0)) return const_cast(C1); // X | 0 == X + if (CI2->equalsInt(0)) return C1; // X | 0 == X if (CI2->isAllOnesValue()) - return const_cast(C2); // X | -1 == -1 + return C2; // X | -1 == -1 break; case Instruction::Xor: - if (CI2->equalsInt(0)) return const_cast(C1); // X ^ 0 == X + if (CI2->equalsInt(0)) return C1; // X ^ 0 == X break; case Instruction::AShr: // ashr (zext C to Ty), C2 -> lshr (zext C, CSA), C2 - if (const ConstantExpr *CE1 = dyn_cast(C1)) + if (ConstantExpr *CE1 = dyn_cast(C1)) if (CE1->getOpcode() == Instruction::ZExt) // Top bits known zero. - return ConstantExpr::getLShr(const_cast(C1), - const_cast(C2)); + return ConstantExpr::getLShr(C1, C2); break; } } // At this point we know neither constant is an UndefValue. - if (const ConstantInt *CI1 = dyn_cast(C1)) { - if (const ConstantInt *CI2 = dyn_cast(C2)) { + if (ConstantInt *CI1 = dyn_cast(C1)) { + if (ConstantInt *CI2 = dyn_cast(C2)) { using namespace APIntOps; const APInt &C1V = CI1->getValue(); const APInt &C2V = CI2->getValue(); @@ -786,13 +783,13 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context, case Instruction::LShr: case Instruction::AShr: case Instruction::Shl: - if (CI1->equalsInt(0)) return const_cast(C1); + if (CI1->equalsInt(0)) return C1; break; default: break; } - } else if (const ConstantFP *CFP1 = dyn_cast(C1)) { - if (const ConstantFP *CFP2 = dyn_cast(C2)) { + } else if (ConstantFP *CFP1 = dyn_cast(C1)) { + if (ConstantFP *CFP2 = dyn_cast(C2)) { APFloat C1V = CFP1->getValueAPF(); APFloat C2V = CFP2->getValueAPF(); APFloat C3V = C1V; // copy for modification @@ -817,14 +814,14 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context, } } } else if (const VectorType *VTy = dyn_cast(C1->getType())) { - const ConstantVector *CP1 = dyn_cast(C1); - const ConstantVector *CP2 = dyn_cast(C2); + ConstantVector *CP1 = dyn_cast(C1); + ConstantVector *CP2 = dyn_cast(C2); if ((CP1 != NULL || isa(C1)) && (CP2 != NULL || isa(C2))) { std::vector Res; const Type* EltTy = VTy->getElementType(); - const Constant *C1 = 0; - const Constant *C2 = 0; + Constant *C1 = 0; + Constant *C2 = 0; switch (Opcode) { default: break; @@ -832,144 +829,126 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context, for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getAdd(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getAdd(C1, C2)); } return ConstantVector::get(Res); case Instruction::FAdd: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getFAdd(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getFAdd(C1, C2)); } return ConstantVector::get(Res); case Instruction::Sub: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getSub(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getSub(C1, C2)); } return ConstantVector::get(Res); case Instruction::FSub: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getFSub(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getFSub(C1, C2)); } return ConstantVector::get(Res); case Instruction::Mul: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getMul(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getMul(C1, C2)); } return ConstantVector::get(Res); case Instruction::FMul: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getFMul(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getFMul(C1, C2)); } return ConstantVector::get(Res); case Instruction::UDiv: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getUDiv(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getUDiv(C1, C2)); } return ConstantVector::get(Res); case Instruction::SDiv: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getSDiv(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getSDiv(C1, C2)); } return ConstantVector::get(Res); case Instruction::FDiv: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getFDiv(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getFDiv(C1, C2)); } return ConstantVector::get(Res); case Instruction::URem: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getURem(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getURem(C1, C2)); } return ConstantVector::get(Res); case Instruction::SRem: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getSRem(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getSRem(C1, C2)); } return ConstantVector::get(Res); case Instruction::FRem: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getFRem(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getFRem(C1, C2)); } return ConstantVector::get(Res); case Instruction::And: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getAnd(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getAnd(C1, C2)); } return ConstantVector::get(Res); case Instruction::Or: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getOr(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getOr(C1, C2)); } return ConstantVector::get(Res); case Instruction::Xor: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getXor(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getXor(C1, C2)); } return ConstantVector::get(Res); case Instruction::LShr: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getLShr(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getLShr(C1, C2)); } return ConstantVector::get(Res); case Instruction::AShr: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getAShr(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getAShr(C1, C2)); } return ConstantVector::get(Res); case Instruction::Shl: for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy); C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy); - Res.push_back(ConstantExpr::getShl(const_cast(C1), - const_cast(C2))); + Res.push_back(ConstantExpr::getShl(C1, C2)); } return ConstantVector::get(Res); } @@ -1015,22 +994,20 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context, switch (Opcode) { case Instruction::Add: case Instruction::Sub: - return ConstantExpr::getXor(const_cast(C1), - const_cast(C2)); + return ConstantExpr::getXor(C1, C2); case Instruction::Mul: - return ConstantExpr::getAnd(const_cast(C1), - const_cast(C2)); + return ConstantExpr::getAnd(C1, C2); case Instruction::Shl: case Instruction::LShr: case Instruction::AShr: // We can assume that C2 == 0. If it were one the result would be // undefined because the shift value is as large as the bitwidth. - return const_cast(C1); + return C1; case Instruction::SDiv: case Instruction::UDiv: // We can assume that C2 == 1. If it were zero the result would be // undefined through division by zero. - return const_cast(C1); + return C1; case Instruction::URem: case Instruction::SRem: // We can assume that C2 == 1. If it were zero the result would be @@ -1114,8 +1091,7 @@ static int IdxCompare(LLVMContext &Context, Constant *C1, Constant *C2, /// 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(LLVMContext &Context, - const Constant *V1, - const Constant *V2) { + Constant *V1, Constant *V2) { assert(V1->getType() == V2->getType() && "Cannot compare values of different types!"); @@ -1130,18 +1106,16 @@ static FCmpInst::Predicate evaluateFCmpRelation(LLVMContext &Context, if (!isa(V2)) { // We distilled thisUse the standard constant folder for a few cases ConstantInt *R = 0; - Constant *C1 = const_cast(V1); - Constant *C2 = const_cast(V2); R = dyn_cast( - ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, C1, C2)); + ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, V1, V2)); if (R && !R->isZero()) return FCmpInst::FCMP_OEQ; R = dyn_cast( - ConstantExpr::getFCmp(FCmpInst::FCMP_OLT, C1, C2)); + ConstantExpr::getFCmp(FCmpInst::FCMP_OLT, V1, V2)); if (R && !R->isZero()) return FCmpInst::FCMP_OLT; R = dyn_cast( - ConstantExpr::getFCmp(FCmpInst::FCMP_OGT, C1, C2)); + ConstantExpr::getFCmp(FCmpInst::FCMP_OGT, V1, V2)); if (R && !R->isZero()) return FCmpInst::FCMP_OGT; @@ -1156,7 +1130,7 @@ static FCmpInst::Predicate evaluateFCmpRelation(LLVMContext &Context, } else { // Ok, the LHS is known to be a constantexpr. The RHS can be any of a // constantexpr or a simple constant. - const ConstantExpr *CE1 = cast(V1); + ConstantExpr *CE1 = cast(V1); switch (CE1->getOpcode()) { case Instruction::FPTrunc: case Instruction::FPExt: @@ -1186,8 +1160,8 @@ static FCmpInst::Predicate evaluateFCmpRelation(LLVMContext &Context, /// GlobalValues, followed by ConstantExpr's (the most complex). /// static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context, - const Constant *V1, - const Constant *V2, + Constant *V1, + Constant *V2, bool isSigned) { assert(V1->getType() == V2->getType() && "Cannot compare different types of values!"); @@ -1198,18 +1172,16 @@ static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context, // We distilled this down to a simple case, use the standard constant // folder. ConstantInt *R = 0; - Constant *C1 = const_cast(V1); - Constant *C2 = const_cast(V2); ICmpInst::Predicate pred = ICmpInst::ICMP_EQ; - R = dyn_cast(ConstantExpr::getICmp(pred, C1, C2)); + R = dyn_cast(ConstantExpr::getICmp(pred, V1, V2)); if (R && !R->isZero()) return pred; pred = isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT; - R = dyn_cast(ConstantExpr::getICmp(pred, C1, C2)); + R = dyn_cast(ConstantExpr::getICmp(pred, V1, V2)); if (R && !R->isZero()) return pred; pred = isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT; - R = dyn_cast(ConstantExpr::getICmp(pred, C1, C2)); + R = dyn_cast(ConstantExpr::getICmp(pred, V1, V2)); if (R && !R->isZero()) return pred; @@ -1249,8 +1221,8 @@ static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context, } else { // Ok, the LHS is known to be a constantexpr. The RHS can be any of a // constantexpr, a CPR, or a simple constant. - const ConstantExpr *CE1 = cast(V1); - const Constant *CE1Op0 = CE1->getOperand(0); + ConstantExpr *CE1 = cast(V1); + Constant *CE1Op0 = CE1->getOperand(0); switch (CE1->getOpcode()) { case Instruction::Trunc: @@ -1281,7 +1253,7 @@ static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context, // from the same type as the src of the LHS, evaluate the inputs. This is // important for things like "icmp eq (cast 4 to int*), (cast 5 to int*)", // which happens a lot in compilers with tagged integers. - if (const ConstantExpr *CE2 = dyn_cast(V2)) + if (ConstantExpr *CE2 = dyn_cast(V2)) if (CE2->isCast() && isa(CE1->getType()) && CE1->getOperand(0)->getType() == CE2->getOperand(0)->getType() && CE1->getOperand(0)->getType()->isInteger()) { @@ -1346,8 +1318,8 @@ static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context, } } } else { - const ConstantExpr *CE2 = cast(V2); - const Constant *CE2Op0 = CE2->getOperand(0); + ConstantExpr *CE2 = cast(V2); + Constant *CE2Op0 = CE2->getOperand(0); // There are MANY other foldings that we could perform here. They will // probably be added on demand, as they seem needed. @@ -1414,8 +1386,7 @@ static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context, Constant *llvm::ConstantFoldCompareInstruction(LLVMContext &Context, unsigned short pred, - const Constant *C1, - const Constant *C2) { + Constant *C1, Constant *C2) { const Type *ResultTy; if (const VectorType *VT = dyn_cast(C1->getType())) ResultTy = VectorType::get(Type::getInt1Ty(Context), VT->getNumElements()); @@ -1728,13 +1699,13 @@ static bool isInBoundsIndices(Constant *const *Idxs, size_t NumIdx) { } Constant *llvm::ConstantFoldGetElementPtr(LLVMContext &Context, - const Constant *C, + Constant *C, bool inBounds, Constant* const *Idxs, unsigned NumIdx) { if (NumIdx == 0 || (NumIdx == 1 && Idxs[0]->isNullValue())) - return const_cast(C); + return C; if (isa(C)) { const PointerType *Ptr = cast(C->getType()); @@ -1764,7 +1735,7 @@ Constant *llvm::ConstantFoldGetElementPtr(LLVMContext &Context, } } - if (ConstantExpr *CE = dyn_cast(const_cast(C))) { + if (ConstantExpr *CE = dyn_cast(C)) { // Combine Indices - If the source pointer to this getelementptr instruction // is a getelementptr instruction, combine the indices of the two // getelementptr instructions into a single instruction. @@ -1904,18 +1875,16 @@ Constant *llvm::ConstantFoldGetElementPtr(LLVMContext &Context, for (unsigned i = 0; i != NumIdx; ++i) if (!NewIdxs[i]) NewIdxs[i] = Idxs[i]; return inBounds ? - ConstantExpr::getInBoundsGetElementPtr(const_cast(C), - NewIdxs.data(), NewIdxs.size()) : - ConstantExpr::getGetElementPtr(const_cast(C), - NewIdxs.data(), NewIdxs.size()); + ConstantExpr::getInBoundsGetElementPtr(C, NewIdxs.data(), + NewIdxs.size()) : + ConstantExpr::getGetElementPtr(C, NewIdxs.data(), NewIdxs.size()); } // If all indices are known integers and normalized, we can do a simple // check for the "inbounds" property. if (!Unknown && !inBounds && isa(C) && isInBoundsIndices(Idxs, NumIdx)) - return ConstantExpr::getInBoundsGetElementPtr(const_cast(C), - Idxs, NumIdx); + return ConstantExpr::getInBoundsGetElementPtr(C, Idxs, NumIdx); return 0; } diff --git a/lib/VMCore/ConstantFold.h b/lib/VMCore/ConstantFold.h index f4452c98bc1..cc97001e3cf 100644 --- a/lib/VMCore/ConstantFold.h +++ b/lib/VMCore/ConstantFold.h @@ -29,41 +29,39 @@ namespace llvm { Constant *ConstantFoldCastInstruction( LLVMContext &Context, unsigned opcode, ///< The opcode of the cast - const Constant *V, ///< The source constant + Constant *V, ///< The source constant const Type *DestTy ///< The destination type ); Constant *ConstantFoldSelectInstruction(LLVMContext &Context, - const Constant *Cond, - const Constant *V1, - const Constant *V2); + Constant *Cond, + Constant *V1, Constant *V2); Constant *ConstantFoldExtractElementInstruction(LLVMContext &Context, - const Constant *Val, - const Constant *Idx); + Constant *Val, + Constant *Idx); Constant *ConstantFoldInsertElementInstruction(LLVMContext &Context, - const Constant *Val, - const Constant *Elt, - const Constant *Idx); + Constant *Val, + Constant *Elt, + Constant *Idx); Constant *ConstantFoldShuffleVectorInstruction(LLVMContext &Context, - const Constant *V1, - const Constant *V2, - const Constant *Mask); + Constant *V1, + Constant *V2, + Constant *Mask); Constant *ConstantFoldExtractValueInstruction(LLVMContext &Context, - const Constant *Agg, + Constant *Agg, const unsigned *Idxs, unsigned NumIdx); Constant *ConstantFoldInsertValueInstruction(LLVMContext &Context, - const Constant *Agg, - const Constant *Val, - const unsigned* Idxs, + Constant *Agg, + Constant *Val, + const unsigned *Idxs, unsigned NumIdx); Constant *ConstantFoldBinaryInstruction(LLVMContext &Context, - unsigned Opcode, const Constant *V1, - const Constant *V2); + unsigned Opcode, Constant *V1, + Constant *V2); Constant *ConstantFoldCompareInstruction(LLVMContext &Context, unsigned short predicate, - const Constant *C1, - const Constant *C2); - Constant *ConstantFoldGetElementPtr(LLVMContext &Context, const Constant *C, + Constant *C1, Constant *C2); + Constant *ConstantFoldGetElementPtr(LLVMContext &Context, Constant *C, bool inBounds, Constant* const *Idxs, unsigned NumIdx); } // End llvm namespace