Changes in directory llvm/lib/Analysis:
ConstantRange.cpp updated: 1.35 -> 1.36 ScalarEvolution.cpp updated: 1.93 -> 1.94 --- Log message: For PR1205: http://llvm.org/PR1205 : First round of ConstantRange changes. This makes all CR constructors use only APInt and not use ConstantInt. Clients are adjusted accordingly. --- Diffs of the changes: (+23 -49) ConstantRange.cpp | 61 +++++++++++++++------------------------------------- ScalarEvolution.cpp | 11 ++++----- 2 files changed, 23 insertions(+), 49 deletions(-) Index: llvm/lib/Analysis/ConstantRange.cpp diff -u llvm/lib/Analysis/ConstantRange.cpp:1.35 llvm/lib/Analysis/ConstantRange.cpp:1.36 --- llvm/lib/Analysis/ConstantRange.cpp:1.35 Wed Feb 28 11:36:23 2007 +++ llvm/lib/Analysis/ConstantRange.cpp Wed Feb 28 12:57:32 2007 @@ -45,28 +45,7 @@ /// Initialize a range to hold the single specified value. /// -ConstantRange::ConstantRange(Constant *V) - : Lower(cast<ConstantInt>(V)->getValue()), - Upper(cast<ConstantInt>(V)->getValue() + 1) { } - -/// Initialize a range of values explicitly... this will assert out if -/// Lower==Upper and Lower != Min or Max for its type (or if the two constants -/// have different types) -/// -ConstantRange::ConstantRange(Constant *L, Constant *U) - : Lower(cast<ConstantInt>(L)->getValue()), - Upper(cast<ConstantInt>(U)->getValue()) { - assert(L->getType() == U->getType() && "Invalid ConstantRange types!"); - assert(L->getType()->isInteger() && "Invalid ConstantRange types!"); - - // Make sure that if L & U are equal that they are either Min or Max... - - uint32_t BitWidth = cast<IntegerType>(L->getType())->getBitWidth(); - const IntegerType *Ty = cast<IntegerType>(L->getType()); - assert((L != U || (L == ConstantInt::get(Ty, APInt::getMaxValue(BitWidth)) - || L == ConstantInt::get(Ty, APInt::getMinValue(BitWidth)))) - && "Lower == Upper, but they aren't min or max for type!"); -} +ConstantRange::ConstantRange(const APInt & V) : Lower(V), Upper(V + 1) { } ConstantRange::ConstantRange(const APInt &L, const APInt &U) : Lower(L), Upper(U) { @@ -80,45 +59,43 @@ /// Initialize a set of values that all satisfy the condition with C. /// -ConstantRange::ConstantRange(unsigned short ICmpOpcode, ConstantInt *C) - : Lower(cast<IntegerType>(C->getType())->getBitWidth(), 0), - Upper(cast<IntegerType>(C->getType())->getBitWidth(), 0) { - const APInt& Val = C->getValue(); - uint32_t BitWidth = cast<IntegerType>(C->getType())->getBitWidth(); +ConstantRange::ConstantRange(unsigned short ICmpOpcode, const APInt &C) + : Lower(C.getBitWidth(), 0), Upper(C.getBitWidth(), 0) { + uint32_t BitWidth = C.getBitWidth(); switch (ICmpOpcode) { default: assert(0 && "Invalid ICmp opcode to ConstantRange ctor!"); - case ICmpInst::ICMP_EQ: Lower = Val; Upper = Val + 1; return; - case ICmpInst::ICMP_NE: Upper = Val; Lower = Val + 1; return; + case ICmpInst::ICMP_EQ: Lower = C; Upper = C + 1; return; + case ICmpInst::ICMP_NE: Upper = C; Lower = C + 1; return; case ICmpInst::ICMP_ULT: Lower = APInt::getMinValue(BitWidth); - Upper = Val; + Upper = C; return; case ICmpInst::ICMP_SLT: Lower = APInt::getSignedMinValue(BitWidth); - Upper = Val; + Upper = C; return; case ICmpInst::ICMP_UGT: - Lower = Val + 1; + Lower = C + 1; Upper = APInt::getMinValue(BitWidth); // Min = Next(Max) return; case ICmpInst::ICMP_SGT: - Lower = Val + 1; + Lower = C + 1; Upper = APInt::getSignedMinValue(BitWidth); // Min = Next(Max) return; case ICmpInst::ICMP_ULE: Lower = APInt::getMinValue(BitWidth); - Upper = Val + 1; + Upper = C + 1; return; case ICmpInst::ICMP_SLE: Lower = APInt::getSignedMinValue(BitWidth); - Upper = Val + 1; + Upper = C + 1; return; case ICmpInst::ICMP_UGE: - Lower = Val; + Lower = C; Upper = APInt::getMinValue(BitWidth); // Min = Next(Max) return; case ICmpInst::ICMP_SGE: - Lower = Val; + Lower = C; Upper = APInt::getSignedMinValue(BitWidth); // Min = Next(Max) return; } @@ -243,14 +220,14 @@ } else { // No overlap on the right, just on the left. - return ConstantRange(RHS.getLower(), LHS.getUpper()); + return ConstantRange(RHS.Lower, LHS.Upper); } } else { // We don't overlap on the left side of RHS, see if we overlap on the right // of RHS... if (GT) { // Simple overlap... - return ConstantRange(LHS.getLower(), RHS.getUpper()); + return ConstantRange(LHS.Lower, RHS.Upper); } else { // No overlap... return ConstantRange(LHS.getType(), false); @@ -319,11 +296,9 @@ unsigned SrcTySize = Lower.getBitWidth(); unsigned DstTySize = Ty->getPrimitiveSizeInBits(); assert(SrcTySize < DstTySize && "Not a value extension"); - if (isFullSet()) { + if (isFullSet()) // Change a source full set into [0, 1 << 8*numbytes) - return ConstantRange(Constant::getNullValue(Ty), - ConstantInt::get(Ty, 1ULL << SrcTySize)); - } + return ConstantRange(APInt(DstTySize,0), APInt(DstTySize,1).shl(SrcTySize)); APInt L = Lower; L.zext(DstTySize); APInt U = Upper; U.zext(DstTySize); Index: llvm/lib/Analysis/ScalarEvolution.cpp diff -u llvm/lib/Analysis/ScalarEvolution.cpp:1.93 llvm/lib/Analysis/ScalarEvolution.cpp:1.94 --- llvm/lib/Analysis/ScalarEvolution.cpp:1.93 Thu Feb 1 20:16:21 2007 +++ llvm/lib/Analysis/ScalarEvolution.cpp Wed Feb 28 12:57:32 2007 @@ -177,7 +177,7 @@ } ConstantRange SCEVConstant::getValueRange() const { - return ConstantRange(V); + return ConstantRange(V->getValue()); } const Type *SCEVConstant::getType() const { return V->getType(); } @@ -490,12 +490,11 @@ // Handle this case efficiently, it is common to have constant iteration // counts while computing loop exit values. if (SCEVConstant *SC = dyn_cast<SCEVConstant>(V)) { - uint64_t Val = SC->getValue()->getZExtValue(); - uint64_t Result = 1; + APInt Val = SC->getValue()->getValue(); + APInt Result(Val.getBitWidth(), 1); for (; NumSteps; --NumSteps) Result *= Val-(NumSteps-1); - Constant *Res = ConstantInt::get(Type::Int64Ty, Result); - return SCEVUnknown::get(ConstantExpr::getTruncOrBitCast(Res, V->getType())); + return SCEVUnknown::get(ConstantInt::get(V->getType(), Result)); } const Type *Ty = V->getType(); @@ -1567,7 +1566,7 @@ ConstantExpr::getBitCast(CompVal, RealTy)); if (CompVal) { // Form the constant range. - ConstantRange CompRange(Cond, CompVal); + ConstantRange CompRange(Cond, CompVal->getValue()); SCEVHandle Ret = AddRec->getNumIterationsInRange(CompRange, false /*Always treat as unsigned range*/); _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits