ConstantRange
ConstantRange::udiv(const ConstantRange &RHS) const {
if (isEmptySet() || RHS.isEmptySet() || RHS.getUnsignedMax() == 0)
return ConstantRange(getBitWidth(), /*isFullSet=*/false);
if (RHS.isFullSet())
return ConstantRange(getBitWidth(), /*isFullSet=*/true);
APInt Lower = getUnsignedMin().udiv(RHS.getUnsignedMax());
APInt RHS_umin = RHS.getUnsignedMin();
if (RHS_umin == 0) {
// We want the lowest value in RHS excluding zero. Usually that would be 1
// except for a range in the form of [X, 1) in which case it would be X.
if (RHS.getUpper() == 1)
RHS_umin = RHS.getLower();
else
RHS_umin = APInt(getBitWidth(), 1);
}
APInt Upper = getUnsignedMax().udiv(RHS_umin) + 1;
// If the LHS is Full and the RHS is a wrapped interval containing 1 then
// this could occur.
if (Lower == Upper)
return ConstantRange(getBitWidth(), /*isFullSet=*/true);
return ConstantRange(Lower, Upper);
}
/// intersectWith - Return the range that results from the intersection of this
/// range with another range.
///
ConstantRange ConstantRange::intersectWith(const ConstantRange &CR) const {
assert(getBitWidth() == CR.getBitWidth() &&
"ConstantRange types don't agree!");
// Handle common special cases
if (isEmptySet() || CR.isFullSet())
return *this;
if (isFullSet() || CR.isEmptySet())
return CR;
if (!isWrappedSet()) {
if (!CR.isWrappedSet()) {
using namespace APIntOps;
APInt L = umax(Lower, CR.Lower);
APInt U = umin(Upper, CR.Upper);
if (L.ult(U)) // If range isn't empty...
return ConstantRange(L, U);
else
return ConstantRange(getBitWidth(), false);// Otherwise, empty set
} else
return intersect1Wrapped(CR, *this);
} else { // We know "this" is wrapped...
if (!CR.isWrappedSet())
return intersect1Wrapped(*this, CR);
else {
// Both ranges are wrapped...
using namespace APIntOps;
APInt L = umax(Lower, CR.Lower);
APInt U = umin(Upper, CR.Upper);
return ConstantRange(L, U);
}
}
return *this;
}
bool
ConstantRange::isSizeStrictlySmallerThan(const ConstantRange &Other) const {
assert(getBitWidth() == Other.getBitWidth());
if (isFullSet())
return false;
if (Other.isFullSet())
return true;
return (Upper - Lower).ult(Other.Upper - Other.Lower);
}
ConstantRange
ConstantRange::multiply(const ConstantRange &Other) const {
if (isEmptySet() || Other.isEmptySet())
return ConstantRange(getBitWidth(), /*isFullSet=*/false);
if (isFullSet() || Other.isFullSet())
return ConstantRange(getBitWidth(), /*isFullSet=*/true);
APInt this_min = getUnsignedMin().zext(getBitWidth() * 2);
APInt this_max = getUnsignedMax().zext(getBitWidth() * 2);
APInt Other_min = Other.getUnsignedMin().zext(getBitWidth() * 2);
APInt Other_max = Other.getUnsignedMax().zext(getBitWidth() * 2);
ConstantRange Result_zext = ConstantRange(this_min * Other_min,
this_max * Other_max + 1);
return Result_zext.truncate(getBitWidth());
}
/// contains - Return true if the argument is a subset of this range.
/// Two equal sets contain each other. The empty set contained by all other
/// sets.
///
bool ConstantRange::contains(const ConstantRange &Other) const {
if (isFullSet() || Other.isEmptySet()) return true;
if (isEmptySet() || Other.isFullSet()) return false;
if (!isWrappedSet()) {
if (Other.isWrappedSet())
return false;
return Lower.ule(Other.getLower()) && Other.getUpper().ule(Upper);
}
if (!Other.isWrappedSet())
return Other.getUpper().ule(Upper) ||
Lower.ule(Other.getLower());
return Other.getUpper().ule(Upper) && Lower.ule(Other.getLower());
}
ConstantRange
ConstantRange::sub(const ConstantRange &Other) const {
if (isEmptySet() || Other.isEmptySet())
return ConstantRange(getBitWidth(), /*isFullSet=*/false);
if (isFullSet() || Other.isFullSet())
return ConstantRange(getBitWidth(), /*isFullSet=*/true);
APInt NewLower = getLower() - Other.getUpper() + 1;
APInt NewUpper = getUpper() - Other.getLower();
if (NewLower == NewUpper)
return ConstantRange(getBitWidth(), /*isFullSet=*/true);
ConstantRange X = ConstantRange(std::move(NewLower), std::move(NewUpper));
if (X.isSizeStrictlySmallerThan(*this) ||
X.isSizeStrictlySmallerThan(Other))
// We've wrapped, therefore, full set.
return ConstantRange(getBitWidth(), /*isFullSet=*/true);
return X;
}
ConstantRange
ConstantRange::sub(const ConstantRange &Other) const {
if (isEmptySet() || Other.isEmptySet())
return ConstantRange(getBitWidth(), /*isFullSet=*/false);
if (isFullSet() || Other.isFullSet())
return ConstantRange(getBitWidth(), /*isFullSet=*/true);
APInt Spread_X = getSetSize(), Spread_Y = Other.getSetSize();
APInt NewLower = getLower() - Other.getUpper() + 1;
APInt NewUpper = getUpper() - Other.getLower();
if (NewLower == NewUpper)
return ConstantRange(getBitWidth(), /*isFullSet=*/true);
ConstantRange X = ConstantRange(NewLower, NewUpper);
if (X.getSetSize().ult(Spread_X) || X.getSetSize().ult(Spread_Y))
// We've wrapped, therefore, full set.
return ConstantRange(getBitWidth(), /*isFullSet=*/true);
return X;
}
ConstantRange
ConstantRange::multiply(const ConstantRange &Other) const {
// TODO: If either operand is a single element and the multiply is known to
// be non-wrapping, round the result min and max value to the appropriate
// multiple of that element. If wrapping is possible, at least adjust the
// range according to the greatest power-of-two factor of the single element.
if (isEmptySet() || Other.isEmptySet())
return ConstantRange(getBitWidth(), /*isFullSet=*/false);
if (isFullSet() || Other.isFullSet())
return ConstantRange(getBitWidth(), /*isFullSet=*/true);
APInt this_min = getUnsignedMin().zext(getBitWidth() * 2);
APInt this_max = getUnsignedMax().zext(getBitWidth() * 2);
APInt Other_min = Other.getUnsignedMin().zext(getBitWidth() * 2);
APInt Other_max = Other.getUnsignedMax().zext(getBitWidth() * 2);
ConstantRange Result_zext = ConstantRange(this_min * Other_min,
this_max * Other_max + 1);
return Result_zext.truncate(getBitWidth());
}
MyConstantRange binaryAnd(const ConstantRange &Other) const {
if (isEmptySet() || Other.isEmptySet())
return MyConstantRange(getBitWidth(), /*isFullSet=*/false);
if (!isWrappedSet() && !Other.isWrappedSet() && !isFullSet() && !Other.isFullSet()) {
unsigned width1 = ((getUpper() - 1) ^ getLower()).logBase2() + 1;
unsigned width2 = ((Other.getUpper() - 1) ^ Other.getLower()).logBase2() + 1;
APInt res1 = getLower().lshr(width1) << width1;
APInt res2 = Other.getLower().lshr(width2) << width2;
APInt res_high1 = getLower();
APInt res_high2 = Other.getLower();
res_high1.setLowBits(width1);
res_high2.setLowBits(width2);
if ((res1 & res2).isNullValue() && (res_high1 & res_high2).isAllOnesValue()) {
return MyConstantRange(getBitWidth(), /*isFullSet=*/true);
}
return MyConstantRange(res1 & res2, (res_high1 & res_high2) + 1);
}
APInt umin = APIntOps::umin(Other.getUnsignedMax(), getUnsignedMax());
if (umin.isAllOnesValue())
return MyConstantRange(getBitWidth(), /*isFullSet=*/true);
return MyConstantRange(APInt::getNullValue(getBitWidth()), std::move(umin) + 1);
}
/// unionWith - Return the range that results from the union of this range with
/// another range. The resultant range is guaranteed to include the elements of
/// both sets, but may contain more. For example, [3, 9) union [12,15) is
/// [3, 15), which includes 9, 10, and 11, which were not included in either
/// set before.
///
ConstantRange ConstantRange::unionWith(const ConstantRange &CR) const {
assert(getBitWidth() == CR.getBitWidth() &&
"ConstantRange types don't agree!");
if ( isFullSet() || CR.isEmptySet()) return *this;
if (CR.isFullSet() || isEmptySet()) return CR;
if (!isWrappedSet() && CR.isWrappedSet()) return CR.unionWith(*this);
if (!isWrappedSet() && !CR.isWrappedSet()) {
if (CR.Upper.ult(Lower) || Upper.ult(CR.Lower)) {
// If the two ranges are disjoint, find the smaller gap and bridge it.
APInt d1 = CR.Lower - Upper, d2 = Lower - CR.Upper;
if (d1.ult(d2))
return ConstantRange(Lower, CR.Upper);
return ConstantRange(CR.Lower, Upper);
}
APInt L = Lower, U = Upper;
if (CR.Lower.ult(L))
L = CR.Lower;
if ((CR.Upper - 1).ugt(U - 1))
U = CR.Upper;
if (L == 0 && U == 0)
return ConstantRange(getBitWidth());
return ConstantRange(L, U);
}
if (!CR.isWrappedSet()) {
// ------U L----- and ------U L----- : this
// L--U L--U : CR
if (CR.Upper.ule(Upper) || CR.Lower.uge(Lower))
return *this;
// ------U L----- : this
// L---------U : CR
if (CR.Lower.ule(Upper) && Lower.ule(CR.Upper))
return ConstantRange(getBitWidth());
// ----U L---- : this
// L---U : CR
// <d1> <d2>
if (Upper.ule(CR.Lower) && CR.Upper.ule(Lower)) {
APInt d1 = CR.Lower - Upper, d2 = Lower - CR.Upper;
if (d1.ult(d2))
return ConstantRange(Lower, CR.Upper);
return ConstantRange(CR.Lower, Upper);
}
// ----U L----- : this
// L----U : CR
if (Upper.ult(CR.Lower) && Lower.ult(CR.Upper))
return ConstantRange(CR.Lower, Upper);
// ------U L---- : this
// L-----U : CR
assert(CR.Lower.ult(Upper) && CR.Upper.ult(Lower) &&
"ConstantRange::unionWith missed a case with one range wrapped");
return ConstantRange(Lower, CR.Upper);
}
// ------U L---- and ------U L---- : this
// -U L----------- and ------------U L : CR
if (CR.Lower.ule(Upper) || Lower.ule(CR.Upper))
return ConstantRange(getBitWidth());
APInt L = Lower, U = Upper;
if (CR.Upper.ugt(U))
U = CR.Upper;
if (CR.Lower.ult(L))
L = CR.Lower;
return ConstantRange(L, U);
}
/// intersectWith - Return the range that results from the intersection of this
/// range with another range. The resultant range is guaranteed to include all
/// elements contained in both input ranges, and to have the smallest possible
/// set size that does so. Because there may be two intersections with the
/// same set size, A.intersectWith(B) might not be equal to B.intersectWith(A).
ConstantRange ConstantRange::intersectWith(const ConstantRange &CR) const {
assert(getBitWidth() == CR.getBitWidth() &&
"ConstantRange types don't agree!");
// Handle common cases.
if ( isEmptySet() || CR.isFullSet()) return *this;
if (CR.isEmptySet() || isFullSet()) return CR;
if (!isWrappedSet() && CR.isWrappedSet())
return CR.intersectWith(*this);
if (!isWrappedSet() && !CR.isWrappedSet()) {
if (Lower.ult(CR.Lower)) {
if (Upper.ule(CR.Lower))
return ConstantRange(getBitWidth(), false);
if (Upper.ult(CR.Upper))
return ConstantRange(CR.Lower, Upper);
return CR;
}
if (Upper.ult(CR.Upper))
return *this;
if (Lower.ult(CR.Upper))
return ConstantRange(Lower, CR.Upper);
return ConstantRange(getBitWidth(), false);
}
if (isWrappedSet() && !CR.isWrappedSet()) {
if (CR.Lower.ult(Upper)) {
if (CR.Upper.ult(Upper))
return CR;
if (CR.Upper.ule(Lower))
return ConstantRange(CR.Lower, Upper);
if (getSetSize().ult(CR.getSetSize()))
return *this;
return CR;
}
if (CR.Lower.ult(Lower)) {
if (CR.Upper.ule(Lower))
return ConstantRange(getBitWidth(), false);
return ConstantRange(Lower, CR.Upper);
}
return CR;
}
if (CR.Upper.ult(Upper)) {
if (CR.Lower.ult(Upper)) {
if (getSetSize().ult(CR.getSetSize()))
return *this;
return CR;
}
if (CR.Lower.ult(Lower))
return ConstantRange(Lower, CR.Upper);
return CR;
}
if (CR.Upper.ule(Lower)) {
if (CR.Lower.ult(Lower))
return *this;
return ConstantRange(CR.Lower, Upper);
}
if (getSetSize().ult(CR.getSetSize()))
return *this;
return CR;
}
/// unionWith - Return the range that results from the union of this range with
/// another range. The resultant range is guaranteed to include the elements of
/// both sets, but may contain more. For example, [3, 9) union [12,15) is
/// [3, 15), which includes 9, 10, and 11, which were not included in either
/// set before.
///
ConstantRange ConstantRange::unionWith(const ConstantRange &CR) const {
assert(getBitWidth() == CR.getBitWidth() &&
"ConstantRange types don't agree!");
if ( isFullSet() || CR.isEmptySet()) return *this;
if (CR.isFullSet() || isEmptySet()) return CR;
if (!isWrappedSet() && CR.isWrappedSet()) return CR.unionWith(*this);
APInt L = Lower, U = Upper;
if (!isWrappedSet() && !CR.isWrappedSet()) {
if (CR.Lower.ult(L))
L = CR.Lower;
if (CR.Upper.ugt(U))
U = CR.Upper;
}
if (isWrappedSet() && !CR.isWrappedSet()) {
if ((CR.Lower.ult(Upper) && CR.Upper.ult(Upper)) ||
(CR.Lower.ugt(Lower) && CR.Upper.ugt(Lower))) {
return *this;
}
if (CR.Lower.ule(Upper) && Lower.ule(CR.Upper)) {
return ConstantRange(getBitWidth());
}
if (CR.Lower.ule(Upper) && CR.Upper.ule(Lower)) {
APInt d1 = CR.Upper - Upper, d2 = Lower - CR.Upper;
if (d1.ult(d2)) {
U = CR.Upper;
} else {
L = CR.Upper;
}
}
if (Upper.ult(CR.Lower) && CR.Upper.ult(Lower)) {
APInt d1 = CR.Lower - Upper, d2 = Lower - CR.Upper;
if (d1.ult(d2)) {
U = CR.Lower + 1;
} else {
L = CR.Upper - 1;
}
}
if (Upper.ult(CR.Lower) && Lower.ult(CR.Upper)) {
APInt d1 = CR.Lower - Upper, d2 = Lower - CR.Lower;
if (d1.ult(d2)) {
U = CR.Lower + 1;
} else {
L = CR.Lower;
}
}
}
if (isWrappedSet() && CR.isWrappedSet()) {
if (Lower.ult(CR.Upper) || CR.Lower.ult(Upper))
return ConstantRange(getBitWidth());
if (CR.Upper.ugt(U)) {
U = CR.Upper;
}
if (CR.Lower.ult(L)) {
L = CR.Lower;
}
if (L == U) return ConstantRange(getBitWidth());
}
return ConstantRange(L, U);
}
