///
virtual const Type *getType() const = 0;
+ /// getBitWidth - Get the bit width of the type, if it has one, 0 otherwise.
+ ///
+ uint32_t getBitWidth() const;
+
/// replaceSymbolicValuesWithConcrete - If this SCEV internally references
/// the symbolic value "Sym", construct and return a new SCEV that produces
/// the same value, but which uses the concrete value Conc instead of the
namespace llvm {
class Constant;
-class ConstantInt;
class Type;
class ConstantRange {
/// getLower - Return the lower value for this range...
///
- ConstantInt *getLower() const;
+ const APInt &getLower() const { return Lower; }
/// getUpper - Return the upper value for this range...
///
- ConstantInt *getUpper() const;
+ const APInt &getUpper() const { return Upper; }
/// getType - Return the LLVM data type of this range.
///
/// The isSigned parameter indicates whether the comparisons should be
/// performed as if the values are signed or not.
///
- bool contains(ConstantInt *Val, bool isSigned) const;
+ bool contains(const APInt &Val, bool isSigned) const;
/// getSingleElement - If this set contains a single element, return it,
/// otherwise return null.
///
- ConstantInt *getSingleElement() const;
+ const APInt *getSingleElement() const {
+ if (Upper == Lower + 1)
+ return &Lower;
+ return 0;
+ }
/// isSingleElement - Return true if this set contains exactly one member.
///
/// subtract - Subtract the specified constant from the endpoints of this
/// constant range.
- ConstantRange subtract(ConstantInt *CI) const;
+ ConstantRange subtract(const APInt &CI) const;
/// intersectWith - Return the range that results from the intersection of
/// this range with another range. The resultant range is pruned as much as
//===----------------------------------------------------------------------===//
#include "llvm/Support/ConstantRange.h"
-#include "llvm/Constants.h"
#include "llvm/Instruction.h"
#include "llvm/Instructions.h"
#include "llvm/Type.h"
return IntegerType::get(Lower.getBitWidth());
}
-ConstantInt *ConstantRange::getLower() const {
- return ConstantInt::get(getType(), Lower);
-}
-
-ConstantInt *ConstantRange::getUpper() const {
- return ConstantInt::get(getType(), Upper);
-}
-
/// isFullSet - Return true if this set contains all of the elements possible
/// for this data-type
bool ConstantRange::isFullSet() const {
return Lower.ugt(Upper);
}
-/// getSingleElement - If this set contains a single element, return it,
-/// otherwise return null.
-ConstantInt *ConstantRange::getSingleElement() const {
- if (Upper == Lower + 1) // Is it a single element range?
- return ConstantInt::get(getType(), Lower);
- return 0;
-}
-
/// getSetSize - Return the number of elements in this set.
///
APInt ConstantRange::getSetSize() const {
/// contains - Return true if the specified value is in the set.
///
-bool ConstantRange::contains(ConstantInt *Val, bool isSigned) const {
+bool ConstantRange::contains(const APInt &V, bool isSigned) const {
if (Lower == Upper) {
if (isFullSet())
return true;
return false;
}
- const APInt &V = Val->getValue();
if (!isWrappedSet(isSigned))
if (isSigned)
return Lower.sle(V) && V.slt(Upper);
/// subtract - Subtract the specified constant from the endpoints of this
/// constant range.
-ConstantRange ConstantRange::subtract(ConstantInt *CI) const {
- assert(CI->getType() == getType() &&
- "Cannot subtract from different type range or non-integer!");
+ConstantRange ConstantRange::subtract(const APInt &Val) const {
+ assert(Val.getBitWidth() == Lower.getBitWidth() && "Wrong bit width");
// If the set is empty or full, don't modify the endpoints.
if (Lower == Upper)
return *this;
-
- const APInt &Val = CI->getValue();
return ConstantRange(Lower - Val, Upper - Val);
}
return ConstantRange(getType());
}
+uint32_t SCEV::getBitWidth() const {
+ if (const IntegerType* ITy = dyn_cast<IntegerType>(getType()))
+ return ITy->getBitWidth();
+ return 0;
+}
+
SCEVCouldNotCompute::SCEVCouldNotCompute() : SCEV(scCouldNotCompute) {}
SCEVHandle Shifted = SCEVAddRecExpr::get(Operands, getLoop());
if (SCEVAddRecExpr *ShiftedAddRec = dyn_cast<SCEVAddRecExpr>(Shifted))
return ShiftedAddRec->getNumIterationsInRange(
- Range.subtract(SC->getValue()),isSigned);
+ Range.subtract(SC->getValue()->getValue()),isSigned);
// This is strange and shouldn't happen.
return new SCEVCouldNotCompute();
}
// First check to see if the range contains zero. If not, the first
// iteration exits.
- ConstantInt *Zero = ConstantInt::get(getType(), 0);
- if (!Range.contains(Zero, isSigned)) return SCEVConstant::get(Zero);
+ if (!Range.contains(APInt(getBitWidth(),0), isSigned))
+ return SCEVConstant::get(ConstantInt::get(getType(),0));
if (isAffine()) {
// If this is an affine expression then we have this situation:
// Since we know that zero is in the range, we know that the upper value of
// the range must be the first possible exit value. Also note that we
// already checked for a full range.
- ConstantInt *Upper = cast<ConstantInt>(Range.getUpper());
- ConstantInt *A = cast<SCEVConstant>(getOperand(1))->getValue();
- ConstantInt *One = ConstantInt::get(getType(), 1);
+ const APInt &Upper = Range.getUpper();
+ APInt A = cast<SCEVConstant>(getOperand(1))->getValue()->getValue();
+ APInt One(getBitWidth(),1);
// The exit value should be (Upper+A-1)/A.
- Constant *ExitValue = Upper;
- if (A != One) {
- ExitValue = ConstantExpr::getSub(ConstantExpr::getAdd(Upper, A), One);
- ExitValue = ConstantExpr::getSDiv(ExitValue, A);
- }
- assert(isa<ConstantInt>(ExitValue) &&
- "Constant folding of integers not implemented?");
+ APInt ExitVal(Upper);
+ if (A != One)
+ ExitVal = (Upper + A - One).sdiv(A);
+ ConstantInt *ExitValue = ConstantInt::get(getType(), ExitVal);
// Evaluate at the exit value. If we really did fall out of the valid
// range, then we computed our trip count, otherwise wrap around or other
// things must have happened.
ConstantInt *Val = EvaluateConstantChrecAtConstant(this, ExitValue);
- if (Range.contains(Val, isSigned))
+ if (Range.contains(Val->getValue(), isSigned))
return new SCEVCouldNotCompute(); // Something strange happened
// Ensure that the previous value is in the range. This is a sanity check.
- assert(Range.contains(EvaluateConstantChrecAtConstant(this,
- ConstantExpr::getSub(ExitValue, One)), isSigned) &&
+ assert(Range.contains(
+ EvaluateConstantChrecAtConstant(this,
+ ConstantInt::get(getType(), ExitVal - One))->getValue(), isSigned) &&
"Linear scev computation is off in a bad way!");
return SCEVConstant::get(cast<ConstantInt>(ExitValue));
} else if (isQuadratic()) {
// terms of figuring out when zero is crossed, instead of when
// Range.getUpper() is crossed.
std::vector<SCEVHandle> NewOps(op_begin(), op_end());
- NewOps[0] = SCEV::getNegativeSCEV(SCEVUnknown::get(Range.getUpper()));
+ NewOps[0] = SCEV::getNegativeSCEV(SCEVUnknown::get(
+ ConstantInt::get(getType(), Range.getUpper())));
SCEVHandle NewAddRec = SCEVAddRecExpr::get(NewOps, getLoop());
// Next, solve the constructed addrec
// for "X*X < 5", for example, we should not return a root of 2.
ConstantInt *R1Val = EvaluateConstantChrecAtConstant(this,
R1->getValue());
- if (Range.contains(R1Val, isSigned)) {
+ if (Range.contains(R1Val->getValue(), isSigned)) {
// The next iteration must be out of the range...
Constant *NextVal =
ConstantExpr::getAdd(R1->getValue(),
ConstantInt::get(R1->getType(), 1));
R1Val = EvaluateConstantChrecAtConstant(this, NextVal);
- if (!Range.contains(R1Val, isSigned))
+ if (!Range.contains(R1Val->getValue(), isSigned))
return SCEVUnknown::get(NextVal);
return new SCEVCouldNotCompute(); // Something strange happened
}
ConstantExpr::getSub(R1->getValue(),
ConstantInt::get(R1->getType(), 1));
R1Val = EvaluateConstantChrecAtConstant(this, NextVal);
- if (Range.contains(R1Val, isSigned))
+ if (Range.contains(R1Val->getValue(), isSigned))
return R1;
return new SCEVCouldNotCompute(); // Something strange happened
}
return new SCEVCouldNotCompute();
// Check to see if we found the value!
- if (!Range.contains(cast<SCEVConstant>(Val)->getValue(), isSigned))
+ if (!Range.contains(cast<SCEVConstant>(Val)->getValue()->getValue(),
+ isSigned))
return SCEVConstant::get(TestVal);
// Increment to test the next index.
//===----------------------------------------------------------------------===//
#include "llvm/Support/ConstantRange.h"
-#include "llvm/Constants.h"
#include "llvm/Instruction.h"
#include "llvm/Instructions.h"
#include "llvm/Type.h"
return IntegerType::get(Lower.getBitWidth());
}
-ConstantInt *ConstantRange::getLower() const {
- return ConstantInt::get(getType(), Lower);
-}
-
-ConstantInt *ConstantRange::getUpper() const {
- return ConstantInt::get(getType(), Upper);
-}
-
/// isFullSet - Return true if this set contains all of the elements possible
/// for this data-type
bool ConstantRange::isFullSet() const {
return Lower.ugt(Upper);
}
-/// getSingleElement - If this set contains a single element, return it,
-/// otherwise return null.
-ConstantInt *ConstantRange::getSingleElement() const {
- if (Upper == Lower + 1) // Is it a single element range?
- return ConstantInt::get(getType(), Lower);
- return 0;
-}
-
/// getSetSize - Return the number of elements in this set.
///
APInt ConstantRange::getSetSize() const {
/// contains - Return true if the specified value is in the set.
///
-bool ConstantRange::contains(ConstantInt *Val, bool isSigned) const {
+bool ConstantRange::contains(const APInt &V, bool isSigned) const {
if (Lower == Upper) {
if (isFullSet())
return true;
return false;
}
- const APInt &V = Val->getValue();
if (!isWrappedSet(isSigned))
if (isSigned)
return Lower.sle(V) && V.slt(Upper);
/// subtract - Subtract the specified constant from the endpoints of this
/// constant range.
-ConstantRange ConstantRange::subtract(ConstantInt *CI) const {
- assert(CI->getType() == getType() &&
- "Cannot subtract from different type range or non-integer!");
+ConstantRange ConstantRange::subtract(const APInt &Val) const {
+ assert(Val.getBitWidth() == Lower.getBitWidth() && "Wrong bit width");
// If the set is empty or full, don't modify the endpoints.
if (Lower == Upper)
return *this;
-
- const APInt &Val = CI->getValue();
return ConstantRange(Lower - Val, Upper - Val);
}
// If we know that this value is a particular constant, set Replacement to
// the constant...
- Value *Replacement = VI.getBounds().getSingleElement();
+ Value *Replacement = 0;
+ const APInt * Rplcmnt = VI.getBounds().getSingleElement();
+ if (Rplcmnt)
+ Replacement = ConstantInt::get(*Rplcmnt);
// If this value is not known to be some constant, figure out the lowest
// rank value that it is known to be equal to (if anything).
projects / oota-llvm.git / commitdiff