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); // Multiplication is signedness-independent. However different ranges can be // obtained depending on how the input ranges are treated. These different // ranges are all conservatively correct, but one might be better than the // other. We calculate two ranges; one treating the inputs as unsigned // and the other signed, then return the smallest of these ranges. // Unsigned range first. 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); ConstantRange UR = Result_zext.truncate(getBitWidth()); // If the unsigned range doesn't wrap, and isn't negative then it's a range // from one positive number to another which is as good as we can generate. // In this case, skip the extra work of generating signed ranges which aren't // going to be better than this range. if (!UR.isWrappedSet() && (UR.getUpper().isNonNegative() || UR.getUpper().isMinSignedValue())) return UR; // Now the signed range. Because we could be dealing with negative numbers // here, the lower bound is the smallest of the cartesian product of the // lower and upper ranges; for example: // [-1,4) * [-2,3) = min(-1*-2, -1*2, 3*-2, 3*2) = -6. // Similarly for the upper bound, swapping min for max. this_min = getSignedMin().sext(getBitWidth() * 2); this_max = getSignedMax().sext(getBitWidth() * 2); Other_min = Other.getSignedMin().sext(getBitWidth() * 2); Other_max = Other.getSignedMax().sext(getBitWidth() * 2); auto L = {this_min * Other_min, this_min * Other_max, this_max * Other_min, this_max * Other_max}; auto Compare = [](const APInt &A, const APInt &B) { return A.slt(B); }; ConstantRange Result_sext(std::min(L, Compare), std::max(L, Compare) + 1); ConstantRange SR = Result_sext.truncate(getBitWidth()); return UR.isSizeStrictlySmallerThan(SR) ? UR : SR; }
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); }
/// 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()); }
static bool tryMergeRange(SmallVectorImpl<Value *> &EndPoints, ConstantInt *Low, ConstantInt *High) { ConstantRange NewRange(Low->getValue(), High->getValue()); unsigned Size = EndPoints.size(); APInt LB = cast<ConstantInt>(EndPoints[Size - 2])->getValue(); APInt LE = cast<ConstantInt>(EndPoints[Size - 1])->getValue(); ConstantRange LastRange(LB, LE); if (canBeMerged(NewRange, LastRange)) { ConstantRange Union = LastRange.unionWith(NewRange); Type *Ty = High->getType(); EndPoints[Size - 2] = ConstantInt::get(Ty, Union.getLower()); EndPoints[Size - 1] = ConstantInt::get(Ty, Union.getUpper()); return true; } return false; }
ConstantRange ConstantRange::makeICmpRegion(unsigned Pred, const ConstantRange &CR) { uint32_t W = CR.getBitWidth(); switch (Pred) { default: assert(!"Invalid ICmp predicate to makeICmpRegion()"); case ICmpInst::ICMP_EQ: return CR; case ICmpInst::ICMP_NE: if (CR.isSingleElement()) return ConstantRange(CR.getUpper(), CR.getLower()); return ConstantRange(W); case ICmpInst::ICMP_ULT: return ConstantRange(APInt::getMinValue(W), CR.getUnsignedMax()); case ICmpInst::ICMP_SLT: return ConstantRange(APInt::getSignedMinValue(W), CR.getSignedMax()); case ICmpInst::ICMP_ULE: { APInt UMax(CR.getUnsignedMax()); if (UMax.isMaxValue()) return ConstantRange(W); return ConstantRange(APInt::getMinValue(W), UMax + 1); } case ICmpInst::ICMP_SLE: { APInt SMax(CR.getSignedMax()); if (SMax.isMaxSignedValue() || (SMax+1).isMaxSignedValue()) return ConstantRange(W); return ConstantRange(APInt::getSignedMinValue(W), SMax + 1); } case ICmpInst::ICMP_UGT: return ConstantRange(CR.getUnsignedMin() + 1, APInt::getNullValue(W)); case ICmpInst::ICMP_SGT: return ConstantRange(CR.getSignedMin() + 1, APInt::getSignedMinValue(W)); case ICmpInst::ICMP_UGE: { APInt UMin(CR.getUnsignedMin()); if (UMin.isMinValue()) return ConstantRange(W); return ConstantRange(UMin, APInt::getNullValue(W)); } case ICmpInst::ICMP_SGE: { APInt SMin(CR.getSignedMin()); if (SMin.isMinSignedValue()) return ConstantRange(W); return ConstantRange(SMin, APInt::getSignedMinValue(W)); } } }
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; }
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); }
ConstantRange ConstantRange::makeAllowedICmpRegion(CmpInst::Predicate Pred, const ConstantRange &CR) { if (CR.isEmptySet()) return CR; uint32_t W = CR.getBitWidth(); switch (Pred) { default: llvm_unreachable("Invalid ICmp predicate to makeAllowedICmpRegion()"); case CmpInst::ICMP_EQ: return CR; case CmpInst::ICMP_NE: if (CR.isSingleElement()) return ConstantRange(CR.getUpper(), CR.getLower()); return ConstantRange(W); case CmpInst::ICMP_ULT: { APInt UMax(CR.getUnsignedMax()); if (UMax.isMinValue()) return ConstantRange(W, /* empty */ false); return ConstantRange(APInt::getMinValue(W), UMax); } case CmpInst::ICMP_SLT: { APInt SMax(CR.getSignedMax()); if (SMax.isMinSignedValue()) return ConstantRange(W, /* empty */ false); return ConstantRange(APInt::getSignedMinValue(W), SMax); } case CmpInst::ICMP_ULE: { APInt UMax(CR.getUnsignedMax()); if (UMax.isMaxValue()) return ConstantRange(W); return ConstantRange(APInt::getMinValue(W), UMax + 1); } case CmpInst::ICMP_SLE: { APInt SMax(CR.getSignedMax()); if (SMax.isMaxSignedValue()) return ConstantRange(W); return ConstantRange(APInt::getSignedMinValue(W), SMax + 1); } case CmpInst::ICMP_UGT: { APInt UMin(CR.getUnsignedMin()); if (UMin.isMaxValue()) return ConstantRange(W, /* empty */ false); return ConstantRange(UMin + 1, APInt::getNullValue(W)); } case CmpInst::ICMP_SGT: { APInt SMin(CR.getSignedMin()); if (SMin.isMaxSignedValue()) return ConstantRange(W, /* empty */ false); return ConstantRange(SMin + 1, APInt::getSignedMinValue(W)); } case CmpInst::ICMP_UGE: { APInt UMin(CR.getUnsignedMin()); if (UMin.isMinValue()) return ConstantRange(W); return ConstantRange(UMin, APInt::getNullValue(W)); } case CmpInst::ICMP_SGE: { APInt SMin(CR.getSignedMin()); if (SMin.isMinSignedValue()) return ConstantRange(W); return ConstantRange(SMin, APInt::getSignedMinValue(W)); } } }
static bool isContiguous(const ConstantRange &A, const ConstantRange &B) { return A.getUpper() == B.getLower() || A.getLower() == B.getUpper(); }